diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 39ea920da..227d810d6 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -72,6 +72,9 @@ jobs:
         if: steps.rust.outputs.required != 'false'
         run: |
           cargo +stable test --workspace --lib --bins --tests --features horizon-client/mods,horizon-mods/pack
+          # The full content-root tests (#[ignore]d: minutes each on a laptop). The same build as above; they need the
+          # prepared vanilla data, so without it they pass at once.
+          cargo +stable test --workspace --lib --features horizon-client/mods,horizon-mods/pack mod_content::tests:: -- --ignored
           cargo +stable test --workspace --doc --features horizon-client/mods,horizon-mods/pack
   # The launcher is its own workspace (launcher/Cargo.toml), so verify's cargo runs never build it. A pull request that
   # changes it or a crate it builds is checked here, and so is every push to main: two pull requests can each pass
@@ -144,6 +147,7 @@ jobs:
     with:
       base: ${{ github.event.pull_request.base.sha }}
       head: ${{ github.event.pull_request.head.sha }}
+      full: ${{ contains(github.event.pull_request.labels.*.name, 'full-parity') }}
   # Horizon never downloads the game. These jobs need a self-hosted Linux runner
   # (label horizon-game) holding the maintainer's own copy: the official launcher's
   # game directory in HORIZON_MINECRAFT_DIR and the pinned server jar in
diff --git a/.github/workflows/parity-main.yml b/.github/workflows/parity-main.yml
index 70fb33796..4840b98be 100644
--- a/.github/workflows/parity-main.yml
+++ b/.github/workflows/parity-main.yml
@@ -25,8 +25,8 @@ jobs:
   parity-main:
     # A Mac mini runner of its own (ludovics-mac-mini-2 holds only this label since 2026-10-26): behind PR parity jobs
     # this run waited 2 h while every merge replaced the pending one, and on the release runner a release then waited
-    # behind the next run. PR parity jobs have ludovics-mac-mini and the desktop. Not the desktop: a job slowed down
-    # because the maintainer came back could time out, and a failure here bisects and comments on merges.
+    # behind the next run. PR parity jobs have ludovics-mac-mini and playhorizon. Not playhorizon: its 4 CPUs
+    # make a core-crate run several times longer, and a failure here bisects and comments on merges.
     runs-on: [self-hosted, macOS, horizon-parity-main]
     timeout-minutes: 240  # a core-crate batch reruns ~300 harnesses (~60-90 min), a bisect a few rounds of the failures
     steps:
diff --git a/.github/workflows/parity.yml b/.github/workflows/parity.yml
index 1fc31d8cb..c850c17aa 100644
--- a/.github/workflows/parity.yml
+++ b/.github/workflows/parity.yml
@@ -1,6 +1,6 @@
 name: parity
-# The vanilla harnesses a pull request's changes can affect, on the Mac mini's runner, which holds the maintainer's
-# own Minecraft files (Horizon never downloads the game). Called by ci.yml for pull requests from this repository
+# The vanilla harnesses a pull request's changes can affect, on the Mac mini's runner or playhorizon's, which hold the
+# maintainer's own Minecraft files (Horizon never downloads the game). Called by ci.yml for pull requests from this repository
 # and by run-parity.yml when a maintainer labels a fork's pull request run-parity. See docs/release-flow.md.
 on:
   workflow_call:
@@ -13,6 +13,13 @@ on:
         description: The commit to check out and test
         type: string
         required: true
+      full:
+        description: >-
+          The pull request carries the full-parity label (a change every harness reaches, such as a crate split): it
+          runs on playhorizon's runner only, so the Mac mini's runners stay free for the others. While that runner is
+          busy the job waits for it.
+        type: boolean
+        default: false
 permissions:
   contents: read
 env:
@@ -21,40 +28,53 @@ env:
 
 jobs:
   parity:
-    runs-on: [self-hosted, horizon-game]
-    timeout-minutes: 120  # a change to core crates reruns ~300 harnesses: ~60-90 min on the Mac mini
+    runs-on: ${{ inputs.full && fromJSON('["self-hosted", "horizon-game", "playhorizon"]') || fromJSON('["self-hosted", "horizon-game"]') }}
+    # A change to core crates reruns ~350 harnesses: ~60-90 min on the Mac mini; on playhorizon (4 of its 8 vCPUs, 4
+    # harnesses at a time) up to a few hours, and any pull request's job may land there.
+    timeout-minutes: ${{ inputs.full && 360 || 180 }}
     steps:
       - uses: actions/checkout@v4
         with:
-          # The commit the event names: a fork's later pushes need another run-parity label.
+          # The commit the event names: a fork's later pushes need another run-parity label. The next step merges
+          # main into it.
           ref: ${{ inputs.head }}
           fetch-depth: 0
           persist-credentials: false
           # Keeps .local/ (parity state, probe builds, oracle results) and target/ between runs.
           clean: false
+      - name: The head merged into main (what merging it would land)
+        id: merge
+        env:
+          BASE_SHA: ${{ inputs.base }}
+          HEAD_SHA: ${{ inputs.head }}
+        run: |
+          # Harness fixes and game fixes that reached main since the branch was made then apply here too: a head
+          # tested alone failed harnesses already fixed on main (server_knockback before #2114, mob_ai's heap before
+          # #2270, save_roundtrip before #2212). Selection then compares with this main, so it sees only the pull
+          # request's own changes. A head that conflicts with main is tested alone.
+          set -euo pipefail
+          git merge --abort 2>/dev/null || true
+          git fetch -q --no-tags origin +refs/heads/main:refs/remotes/origin/main
+          main=$(git rev-parse origin/main)
+          if git -c user.name=parity -c user.email=parity@localhost merge -q --no-edit --no-ff "$main" >/dev/null 2>&1; then
+            echo "base=$main" >> "$GITHUB_OUTPUT"
+            echo "Tested: head ${HEAD_SHA:0:9} merged into main ${main:0:9}" | tee -a "$GITHUB_STEP_SUMMARY"
+          else
+            git merge --abort
+            echo "base=$BASE_SHA" >> "$GITHUB_OUTPUT"
+            echo "::warning::head ${HEAD_SHA:0:9} conflicts with main ${main:0:9}: tested alone, without main's fixes"
+            echo "Tested: head ${HEAD_SHA:0:9} alone (it conflicts with main ${main:0:9})" | tee -a "$GITHUB_STEP_SUMMARY"
+          fi
       - uses: dtolnay/rust-toolchain@stable
       - name: Tools from the runner
         run: bash tools/ci/runner-env.sh
       - name: Vanilla data, and resources prepared by this preparer
-        env:
-          BASE_SHA: ${{ inputs.base }}
-        run: |
-          # main's script: one written before a fix to it left a real .local/horizon-client without sounds.json on
-          # the runner, and every later job there failed `subtitle`. A branch that changes the script runs its own.
-          set -euo pipefail
-          if git rev-parse --verify -q origin/main >/dev/null \
-            && git diff --quiet "$(git merge-base "$BASE_SHA" HEAD)" HEAD -- tools/ci/vanilla-data.sh; then
-            git show origin/main:tools/ci/vanilla-data.sh > "$RUNNER_TEMP/vanilla-data.sh"
-            bash "$RUNNER_TEMP/vanilla-data.sh"
-          else
-            bash tools/ci/vanilla-data.sh
-          fi
+        run: bash tools/ci/vanilla-data.sh
       - name: The prepared output is the one the preparer's OUTPUT_VERSION says
         env:
-          BASE_SHA: ${{ inputs.base }}
+          BASE_SHA: ${{ steps.merge.outputs.base }}
         run: |
-          # The job runs main's workflow on the head's files: a head made before OUTPUT_VERSION (#1947) has neither
-          # the tool nor the number, so there is nothing to check.
+          # A head made before OUTPUT_VERSION (#1947) that conflicts with main has neither the tool nor the number.
           if [ ! -f tools/prepare_output.py ] || ! grep -q OUTPUT_VERSION crates/horizon-prepare/src/lib.rs; then
             echo "This head's preparer has no OUTPUT_VERSION: nothing to check"
             exit 0
@@ -65,47 +85,8 @@ jobs:
       - name: The harnesses this change can affect
         env:
           PARITY_HOSTS: ''
-          BASE_SHA: ${{ inputs.base }}
-        run: |
-          # main's selection (tools/parity.py --changed --list with main's parity.py and parity_reach.py), so a
-          # branch made before a better selection landed gets it too; the head's own runner then runs those
-          # harnesses. A branch that changes the selection itself selects with its own code.
-          set -euo pipefail
-          own() { python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400; }  # world_spawn takes ~1480 s on a busy runner
-          fork_point=$(git merge-base "$BASE_SHA" HEAD)
-          if ! git rev-parse --verify -q origin/main >/dev/null || ! git diff --quiet "$fork_point" HEAD -- tools/parity.py tools/parity_reach.py; then
-            own
-            exit
-          fi
-          had_reach=$(git ls-files tools/parity_reach.py)
-          git show origin/main:tools/parity.py > tools/parity.py
-          git show origin/main:tools/parity_reach.py > tools/parity_reach.py
-          status=0
-          python3 tools/parity.py --changed "$BASE_SHA" --list > .local/parity-selection.txt || status=$?
-          git checkout -- tools/parity.py
-          if [ -n "$had_reach" ]; then git checkout -- tools/parity_reach.py; else rm -f tools/parity_reach.py; fi
-          cat .local/parity-selection.txt
-          if [ "$status" != 0 ]; then
-            echo "main's selection failed: the head's own selection runs"
-            own
-            exit
-          fi
-          names=$(sed '$d' .local/parity-selection.txt | grep -E '^[A-Za-z0-9_#]+$' || true)
-          # The summary line says how many would run: a count that doesn't match the names read (a format change)
-          # must not let the job pass untested.
-          expected=$(tail -1 .local/parity-selection.txt | sed -nE 's/^([0-9]+) of [0-9]+ harnesses would run$/\1/p')
-          count=$(printf '%s' "$names" | grep -c . || true)
-          if [ -z "$expected" ] || [ "$expected" != "$count" ]; then
-            echo "main's selection listed $count names, its summary says '${expected:-?}': the head's own selection runs"
-            own
-            exit
-          fi
-          if [ "$count" = 0 ]; then
-            echo "Nothing to run."
-            exit 0
-          fi
-          # shellcheck disable=SC2086
-          python3 tools/parity.py $names --timeout 2400
+          BASE_SHA: ${{ steps.merge.outputs.base }}
+        run: python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400  # world_spawn takes ~1480 s on a busy runner
       - name: Logs of the failed harnesses
         if: failure()
         uses: actions/upload-artifact@v4
diff --git a/.github/workflows/run-parity.yml b/.github/workflows/run-parity.yml
index a2b8e3291..9089a9a09 100644
--- a/.github/workflows/run-parity.yml
+++ b/.github/workflows/run-parity.yml
@@ -22,3 +22,4 @@ jobs:
     with:
       base: ${{ github.event.pull_request.base.sha }}
       head: ${{ github.event.pull_request.head.sha }}
+      full: ${{ contains(github.event.pull_request.labels.*.name, 'full-parity') }}
diff --git a/AGENTS.md b/AGENTS.md
index e1fa9e7fe..3804ebae8 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -10,7 +10,8 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
   `tools/check_public_tree.py` rejects them; `git config core.hooksPath .githooks` runs it on commit.
 - **Keep your runs away from real player data.** Any game or launcher you start gets fresh `mktemp -d`
   folders in `HORIZON_HOME` (the game's data), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and
-  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`. Never write to
+  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`, and, for the
+  launcher, `HORIZON_LAUNCHER_TRASH`, `HORIZON_LAUNCHER_CLIPBOARD` and `HORIZON_LAUNCHER_DESKTOP` pointing into the scratch home. Never write to
   `~/.local/share/{applications,horizon,horizon-launcher}` or `~/.local/bin`.
 - **Mark what an agent posts.** A PR body starts with a line naming whose agent opened it and with what.
   Ludovic's agents write `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.`, and a
@@ -34,7 +35,9 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 
 | Crate | Owns |
 |---|---|
-| `horizon-client` | The game: a lib (`src/lib.rs`, ~190 flat modules) and the bin (`src/main.rs` → `game.rs` + `game/`), plus `horizon-ctl` (`src/bin/horizon-ctl/`). Also the dedicated server (`--dedicated`) |
+| `horizon-client` | The game: a lib (`src/lib.rs`, ~180 flat modules) and the bin (`src/main.rs` → `game.rs` + `game/`), plus `horizon-ctl` (`src/bin/horizon-ctl/`). Also the dedicated server (`--dedicated`) |
+| `horizon-command` | Command parsing (Brigadier): the vanilla tree, argument types, selectors, suggestions, the tree's network form. Re-exported as `horizon_client::command` |
+| `horizon-client-core` | The client lib's bottom layer: `text.rs`, `lang.rs`, `snbt.rs`, `nbt_path.rs`, `component.rs`, `scoreboard.rs`, `bossbar.rs`, `gamerules.rs`, `block_entity_nbt.rs`, registry/particle/sound tables. Re-exported under the old paths (`horizon_client::text`...) |
 | `horizon-world` | Vanilla world data with no gameplay loop: NBT, regions, chunks, `datafix/`, `worldgen/`, `level/` (server-side block behaviour, ticks, redstone), entity physics, items, effects, food, damage |
 | `horizon-core` | Simulation primitives: Java `Random`s, `jmath` (HotSpot-exact `Math`), positions, noise, density, paletted storage, `version.rs` (the pinned version) |
 | `horizon-protocol` | Network protocol 777: codecs, framing, encryption, `packets/{handshake,status,login,configuration,play}.rs`, `entity_data.rs` |
@@ -63,6 +66,7 @@ reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` an
 python3 tools/pr_ready.py                  # the self-check: fmt, clippy -D warnings, touched crates' tests, harnesses; paste its block in the PR
 python3 tools/pr_ready.py --quick          # same without harnesses
 cargo test -p horizon-client --lib --bins --tests   # skips the 104 examples (pr_ready does this); `--doc` separately
+cargo test -p horizon-client --features horizon-client/mods --lib mod_content::tests:: -- --ignored   # the 5 slow content-root tests, #[ignore]d; pr_ready runs them when mod content, assets, blocks or items change
 cargo build --profile fast -p horizon-client        # optimized, quick to link: use it to play or run lan_e2e
 python3 tools/parity.py --changed origin/main       # the harnesses your branch can affect (CI's parity job)
 python3 tools/parity.py --changed-files paths.txt --list   # which harnesses cover these files, without running them
@@ -118,16 +122,16 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 | Other entities | L: `entities.rs`, `projectiles.rs`, `arrows.rs`; G: `boats.rs`, `minecarts.rs`, `mounts.rs`, `armor_stands.rs`, `paintings.rs`, `frames.rs`, `fireworks.rs`, `tnt.rs`, `explosion.rs` |
 | Player actions | game.rs (`fn use_hand`, `fn use_item`, `fn attack`, `fn tick_mining`, `fn break_block`); G: `hand.rs`, `combat.rs`, `consume.rs`, `potions.rs`, `shield.rs`, `crossbow.rs`, `trident.rs`, `fishing.rs`; L: `motion.rs` + `motion/` (movement), `collisions.rs`, `items.rs`, `item_data.rs` |
 | Inventory and containers | L: `menu.rs` (`AbstractContainerMenu.clicked`), `container_screen.rs`, `containers.rs`, `creative.rs`, `crafting.rs`, `recipe_book*.rs`, `stations.rs`, `merchant.rs`; game.rs `fn menu_ops`, `fn click_inventory`; G: `stations.rs`, `trading.rs`, `recipe_book.rs`, `machines.rs` |
-| Commands | parse: L: `command/` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`); run: G: `commands.rs` (dispatch) + `commands/*.rs` (`admin`, `execute`, `items`, `players`, `world_cmds`...); L: `scoreboard_cmd.rs`, `data_cmd.rs`, `nbt_path.rs`; G: `functions.rs`, `command_blocks.rs` |
+| Commands | parse: crate `horizon-command` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`); run: G: `commands.rs` (dispatch) + `commands/*.rs` (`admin`, `execute`, `items`, `players`, `world_cmds`...); L: `scoreboard_cmd.rs`, `data_cmd.rs`; `horizon-client-core`: `nbt_path.rs`, `scoreboard.rs`; G: `functions.rs`, `command_blocks.rs` |
 | UI screens | `Screen` enum in game.rs; L: `title.rs` + `title/`, `options_ui.rs`, `multiplayer.rs`, `pack_screen.rs`, `graphics_ui.rs`, `screen_draw.rs`, `ui.rs` (widgets), `hud.rs`, `hud_layout.rs`, `hud_overlays.rs`, `chat.rs`, `tab_list.rs`; G: `startup_menu.rs`, `screens.rs` (pause, death), `options.rs`, `lan_screen.rs`, `chat.rs`, `sign_edit.rs`, `books.rs` |
 | Multiplayer client | L: `net.rs` (network thread); G: `remote.rs` (`fn handle_packet`, `fn tick_remote`), `remote_*.rs` (mob data, objects, projectiles, vehicles, stations) |
 | LAN host / server side | L: `lan/` (`conn.rs` handshake + login threads, `hub.rs` + `hub/` play state, `chunks.rs`, `entity.rs`, `tracking.rs`, `guest.rs`, `playerdata.rs`); G: `lan.rs` (`LanHost`), `lan_actions.rs` (`fn as_guest`, `fn tick_guests`), `lan_*.rs` per feature, `lan_entities.rs` (tracked entities) |
 | Integrated server | G: `integrated.rs` (the server thread), `levels.rs` (one level per dimension, `fn tick_server`), `server_travel.rs` |
 | Dedicated server | G: `dedicated.rs`, `dedicated/status.rs`; crates `horizon-server-files`, `horizon-server` |
-| Save and load | L: `save.rs` (level.dat, regions, playerdata), `entity_nbt.rs`, `block_entity_nbt.rs`, `options_file.rs`; G: `saving.rs`, `persist.rs` (entities); `crates/horizon-world/src/{region.rs,nbt.rs,datafix/}` |
+| Save and load | L: `save.rs` (level.dat, regions, playerdata), `entity_nbt.rs`, `options_file.rs`; `horizon-client-core/src/block_entity_nbt.rs`; G: `saving.rs`, `persist.rs` (entities); `crates/horizon-world/src/{region.rs,nbt.rs,datafix/}` |
 | Input | game.rs `fn window_event`, `fn key_pressed`, `fn play_mouse`; L: `keybinds.rs`, `keymapping.rs`, `key_names.rs`, `mouse.rs`, `input.rs`, `interaction_input.rs`, `gamepad.rs`, `osk.rs`, `clipboard.rs`; G: `pad.rs`, `pad_menu.rs` |
 | Audio | L: `audio.rs` (mixer), `sound_engine.rs`, `sound_events.rs`, `music.rs`, `ambience.rs`; G: `music.rs`, `subtitle_hud.rs` |
-| Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`, `lang.rs`; crate `horizon-assets`; G: `packs.rs` |
+| Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`; `horizon-client-core/src/lang.rs`; crate `horizon-assets`; G: `packs.rs` |
 | Agent control | L: `control.rs` (socket), `bin/horizon-ctl/`; G: `control.rs`, `agent.rs`, `events.rs`, `ui_control.rs` ([docs/agent-control.md](docs/agent-control.md)) |
 | Mods | crate `horizon-mods`; G: `mods.rs`; L: `mod_content.rs`, `mod_list.rs` |
 | Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs`, `tweaks.rs`, `options.rs` |
diff --git a/Cargo.lock b/Cargo.lock
index 809df3a5a..e65b25dab 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -216,6 +216,13 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
+[[package]]
+name = "beacons"
+version = "0.1.0"
+dependencies = [
+ "horizon-mod-sdk",
+]
+
 [[package]]
 name = "bit-set"
 version = "0.10.0"
@@ -923,6 +930,13 @@ version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7"
 
+[[package]]
+name = "far-view"
+version = "1.0.0"
+dependencies = [
+ "horizon-mod-sdk",
+]
+
 [[package]]
 name = "fdeflate"
 version = "0.3.7"
@@ -1365,6 +1379,8 @@ dependencies = [
  "glam",
  "horizon-assets",
  "horizon-bench",
+ "horizon-client-core",
+ "horizon-command",
  "horizon-core",
  "horizon-dualsense",
  "horizon-friends",
@@ -1389,6 +1405,7 @@ dependencies = [
  "sha1",
  "sha2",
  "symphonia",
+ "unicode-bidi",
  "ureq",
  "wgpu",
  "winit",
@@ -1396,6 +1413,23 @@ dependencies = [
  "zip",
 ]
 
+[[package]]
+name = "horizon-client-core"
+version = "0.1.0"
+dependencies = [
+ "horizon-world",
+ "serde_json",
+]
+
+[[package]]
+name = "horizon-command"
+version = "0.1.0"
+dependencies = [
+ "horizon-client-core",
+ "horizon-protocol",
+ "horizon-world",
+]
+
 [[package]]
 name = "horizon-core"
 version = "0.1.0"
@@ -2971,6 +3005,13 @@ dependencies = [
  "objc2-quartz-core 0.3.2",
 ]
 
+[[package]]
+name = "recipes"
+version = "1.0.0"
+dependencies = [
+ "horizon-mod-sdk",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.4.1"
@@ -3734,6 +3775,12 @@ version = "1.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
 
+[[package]]
+name = "unicode-bidi"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.26"
diff --git a/Cargo.toml b/Cargo.toml
index 59bfe5e33..8f3153c62 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,46 @@
 [workspace]
 exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"]
-members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-hdr", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/minimap", "mods/official/zoom", "xtask"]
+members = [
+    "crates/horizon-core",
+    "crates/horizon-dualsense",
+    "crates/horizon-threads",
+    "crates/horizon-hdr",
+    "crates/horizon-world",
+    "crates/horizon-client",
+    "crates/horizon-client-core",
+    "crates/horizon-command",
+    "crates/horizon-server-files",
+    "crates/horizon-server",
+    "crates/horizon-bots",
+    "crates/horizon-assets",
+    "crates/horizon-protocol",
+    "crates/horizon-theme",
+    "crates/horizon-prepare",
+    "crates/horizon-telemetry",
+    "crates/horizon-bench",
+    "crates/horizon-friends",
+    "crates/horizon-relay",
+    "crates/horizon-mod-sdk",
+    "crates/horizon-mods",
+    "crates/horizon-mods/tests/guest",
+    "crates/horizon-mods/tests/ui_guest",
+    "crates/cargo-horizon-mod",
+    "crates/horizon-port-pack",
+    "crates/horizon-shaders",
+    "crates/horizon-shader-api",
+    "crates/horizon-release-sign",
+    "crates/horizon-mod-sdk/examples/coords-hud",
+    "crates/horizon-mod-sdk/examples/predator-missile",
+    "crates/horizon-mod-sdk/examples/welcome",
+    "crates/horizon-mod-sdk/examples/beacons",
+    "mods/official/fps-overlay",
+    "mods/official/keystrokes",
+    "mods/official/far-view",
+    "mods/official/minimap",
+    "mods/official/zoom",
+    "xtask",
+    "mods/official/recipes",
+]
 resolver = "2"
 
 [workspace.package]
diff --git a/crates/cargo-horizon-mod/src/check.rs b/crates/cargo-horizon-mod/src/check.rs
index 33095a115..988ba826d 100644
--- a/crates/cargo-horizon-mod/src/check.rs
+++ b/crates/cargo-horizon-mod/src/check.rs
@@ -200,7 +200,7 @@ fn play(path: &Path, report: &mut Report) -> Result<(), String> {
         return Err(format!("it didn't start: {reason}"));
     }
     let client: Vec<String> = mods.commands().map(str::to_owned).collect();
-    let server: Vec<String> = mods.server_commands().map(str::to_owned).collect();
+    let server: Vec<String> = mods.server_commands().map(|c| c.name.clone()).collect();
     report.commands = [client.clone(), server.clone()].concat();
     // A server mod plays with one player on, who joins, chats and leaves.
     let steve = ServerPlayer {
@@ -266,8 +266,17 @@ fn play(path: &Path, report: &mut Report) -> Result<(), String> {
                 format!("{} quiet command(s)", lines.len())
             }
             Output::Stopped { reason, .. } => return Err(format!("it stopped: {reason}")),
+            Output::SetBlocks {
+                dimension, blocks, ..
+            } => {
+                format!("set {} block(s) in {dimension}", blocks.len())
+            }
             Output::OpenScreen { .. } => "opened a screen".to_string(),
             Output::CloseScreen { .. } => "closed its screen".to_string(),
+            Output::PlaceRecipe { book_id, all } => {
+                format!("placed recipe {book_id}{}", if all { " (all)" } else { "" })
+            }
+            Output::Give { item, count, .. } => format!("gave {count} {item}"),
             Output::Shake { strength, seconds } => {
                 format!("shook the camera: {strength:.2} for {seconds:.1} s")
             }
diff --git a/crates/horizon-client-core/Cargo.toml b/crates/horizon-client-core/Cargo.toml
new file mode 100644
index 000000000..8809a5216
--- /dev/null
+++ b/crates/horizon-client-core/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "horizon-client-core"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+rust-version = "1.90"
+description = "The client's lowest layer: chat text and translations, SNBT and NBT paths, the scoreboard, boss bars, game rules and the registry and particle tables commands name"
+
+[dependencies]
+horizon-world = { path = "../horizon-world" }
+serde_json = { version = "1.0.151", features = ["raw_value"] }
+
+[lints]
+workspace = true
diff --git a/crates/horizon-client/src/block_entity_nbt.rs b/crates/horizon-client-core/src/block_entity_nbt.rs
similarity index 98%
rename from crates/horizon-client/src/block_entity_nbt.rs
rename to crates/horizon-client-core/src/block_entity_nbt.rs
index a4c02ba3b..a4387bf48 100644
--- a/crates/horizon-client/src/block_entity_nbt.rs
+++ b/crates/horizon-client-core/src/block_entity_nbt.rs
@@ -61,6 +61,16 @@ fn f32_tag(v: f32) -> Tag {
     Tag::Float(v.to_bits())
 }
 
+/// `TheEndGatewayBlockEntity.loadAdditional`: BlockPos.CODEC and Level.isInSpawnableBounds.
+pub fn gateway_exit(tag: &Tag) -> Option<[i32; 3]> {
+    let Tag::IntArray(v) = tag else { return None };
+    let p: [i32; 3] = v.as_slice().try_into().ok()?;
+    ((-30_000_000..30_000_000).contains(&p[0])
+        && (-20_000_000..20_000_000).contains(&p[1])
+        && (-30_000_000..30_000_000).contains(&p[2]))
+    .then_some(p)
+}
+
 /// What a block entity reads and writes, in `saveAdditional` order.
 struct Fields<'a> {
     input: &'a Tag,
@@ -259,7 +269,7 @@ fn is_pos(tag: &Tag) -> bool {
     matches!(tag, Tag::IntArray(v) if v.len() == 3)
 }
 /// The loaded `SignText` of one side, or the empty text.
-pub(crate) fn sign_side(tag: Option<&Tag>) -> Tag {
+pub fn sign_side(tag: Option<&Tag>) -> Tag {
     let empty = || string("");
     let mut messages: Vec<Tag> = match tag.and_then(|t| t.get("messages")) {
         Some(Tag::List(list)) => list.iter().filter_map(component).collect(),
@@ -424,10 +434,7 @@ pub fn canonical(tag: &Tag) -> Option<Tag> {
         }
         "minecraft:end_gateway" => {
             f.long("Age", 0);
-            f.keep("exit_portal", |t| {
-                is_pos(t)
-                    && matches!(t, Tag::IntArray(v) if v[1].abs() <= 30_000_000 && v[0].abs() <= 30_000_000 && v[2].abs() <= 30_000_000)
-            });
+            f.keep("exit_portal", |t| gateway_exit(t).is_some());
             if flag(tag.get("ExactTeleport")) == Some(true) {
                 f.put("ExactTeleport", boolean(true));
             }
diff --git a/crates/horizon-client/src/bossbar.rs b/crates/horizon-client-core/src/bossbar.rs
similarity index 100%
rename from crates/horizon-client/src/bossbar.rs
rename to crates/horizon-client-core/src/bossbar.rs
diff --git a/crates/horizon-client/src/component.rs b/crates/horizon-client-core/src/component.rs
similarity index 93%
rename from crates/horizon-client/src/component.rs
rename to crates/horizon-client-core/src/component.rs
index fced49898..afb68fa98 100644
--- a/crates/horizon-client/src/component.rs
+++ b/crates/horizon-client-core/src/component.rs
@@ -173,6 +173,22 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style {
     if let Some(e) = o.get("click_event").and_then(Value::as_object) {
         let text = |k: &str| e.get(k).and_then(Value::as_str).map(str::to_owned);
         style.click = match e.get("action").and_then(Value::as_str) {
+            // ClickEvent.OpenUrl.CODEC: ExtraCodecs.UNTRUSTED_URI allows http and
+            // https only, the scheme in any case (Util.parseAndValidateUntrustedUri).
+            Some("open_url") => text("url")
+                .filter(|u| {
+                    u.split_once(':').is_some_and(|(scheme, _)| {
+                        scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https")
+                    })
+                })
+                .map(crate::text::ClickEvent::OpenUrl),
+            // ClickEvent.ChangePage.CODEC: ExtraCodecs.POSITIVE_INT.
+            Some("change_page") => e
+                .get("page")
+                .and_then(Value::as_i64)
+                .and_then(|p| i32::try_from(p).ok())
+                .filter(|p| *p >= 1)
+                .map(crate::text::ClickEvent::ChangePage),
             Some("suggest_command") => text("command").map(crate::text::ClickEvent::SuggestCommand),
             Some("copy_to_clipboard") => {
                 text("value").map(crate::text::ClickEvent::CopyToClipboard)
@@ -252,7 +268,7 @@ pub fn to_text_with(
             } else if let Some(sel) = o.get("selector").and_then(Value::as_str) {
                 resolve(sel)
             } else if let Some(key) = o.get("keybind").and_then(Value::as_str) {
-                crate::keybinds::display_name(key)
+                crate::key_display::display_name(key)
             } else {
                 Text::empty()
             };
diff --git a/crates/horizon-client/src/fastutil_order.rs b/crates/horizon-client-core/src/fastutil_order.rs
similarity index 100%
rename from crates/horizon-client/src/fastutil_order.rs
rename to crates/horizon-client-core/src/fastutil_order.rs
diff --git a/crates/horizon-client/src/gamerules.rs b/crates/horizon-client-core/src/gamerules.rs
similarity index 90%
rename from crates/horizon-client/src/gamerules.rs
rename to crates/horizon-client-core/src/gamerules.rs
index 7198fd202..6715e01ec 100644
--- a/crates/horizon-client/src/gamerules.rs
+++ b/crates/horizon-client-core/src/gamerules.rs
@@ -292,27 +292,4 @@ mod tests {
         assert_eq!(GameRules::load(&dir), rules);
         let _ = fs::remove_dir_all(dir);
     }
-    /// The world's save (Level.write) writes the rules as they are now, and a
-    /// world opened again reads them back (#74).
-    #[test]
-    fn level_save_keeps_changed_rules() {
-        let dir =
-            std::env::temp_dir().join(format!("horizon-gamerules-level-{}", std::process::id()));
-        let _ = fs::remove_dir_all(&dir);
-        let mut level = crate::save::Level::default();
-        level.write(&dir).unwrap();
-        // Rules changed while playing, then saved and loaded again.
-        let mut rules = GameRules::load(&dir);
-        assert_eq!(rules, GameRules::default());
-        assert!(rules.set("advance_time", Value::Bool(false)));
-        assert!(rules.set("advance_weather", Value::Bool(false)));
-        assert!(rules.set("random_tick_speed", Value::Int(0)));
-        level.game_rules = rules.by_name();
-        level.write(&dir).unwrap();
-        assert_eq!(GameRules::load(&dir), rules);
-        let read = crate::save::Level::read(&dir).unwrap();
-        assert_eq!(read.game_rules, rules.by_name());
-        assert_eq!(read.game_rule("advance_time"), 0);
-        let _ = fs::remove_dir_all(dir);
-    }
 }
diff --git a/crates/horizon-client-core/src/identifier.rs b/crates/horizon-client-core/src/identifier.rs
new file mode 100644
index 000000000..1e76f7731
--- /dev/null
+++ b/crates/horizon-client-core/src/identifier.rs
@@ -0,0 +1,18 @@
+//! Resource identifiers (`Identifier`).
+
+/// Identifier.parse: `ns:path` or `path`, validated.
+pub fn parse_identifier(raw: &str) -> Option<String> {
+    let (ns, path) = match raw.split_once(':') {
+        Some(("", path)) => ("minecraft", path),
+        Some((ns, path)) => (ns, path),
+        None => ("minecraft", raw),
+    };
+    let ns_ok = ns != ".."
+        && ns
+            .chars()
+            .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-'));
+    let path_ok = path.chars().all(|c| {
+        c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-' | '/')
+    });
+    (ns_ok && path_ok).then(|| format!("{ns}:{path}"))
+}
diff --git a/crates/horizon-client-core/src/key_display.rs b/crates/horizon-client-core/src/key_display.rs
new file mode 100644
index 000000000..fc57c97bd
--- /dev/null
+++ b/crates/horizon-client-core/src/key_display.rs
@@ -0,0 +1,38 @@
+//! Key display names (`InputConstants.Key.getDisplayName`), shared by key
+//! mappings and `keybind` text components.
+use crate::text::Text;
+
+/// InputConstants.Key.getDisplayName: one-character keys as the upper-case
+/// character, others by translation.
+pub fn display_name(key: &str) -> Text {
+    if let Some(rest) = key.strip_prefix("key.keyboard.")
+        && rest.chars().count() == 1
+    {
+        let c = rest.to_uppercase();
+        return Text::literal(c);
+    }
+    let symbol = match key {
+        "key.keyboard.minus" => Some("-"),
+        "key.keyboard.equal" => Some("="),
+        "key.keyboard.left.bracket" => Some("["),
+        "key.keyboard.right.bracket" => Some("]"),
+        "key.keyboard.backslash" => Some("\\"),
+        "key.keyboard.semicolon" => Some(";"),
+        "key.keyboard.apostrophe" => Some("'"),
+        "key.keyboard.grave.accent" => Some("`"),
+        "key.keyboard.comma" => Some(","),
+        "key.keyboard.period" => Some("."),
+        "key.keyboard.slash" => Some("/"),
+        _ => None,
+    };
+    if let Some(s) = symbol {
+        return Text::literal(s);
+    }
+    if let Some(n) = key.strip_prefix("key.mouse.")
+        && n.parse::<u32>().is_ok()
+        && !crate::lang::has(key)
+    {
+        return Text::translate("key.mouse", &[Text::literal(n)]);
+    }
+    Text::translate(key, &[])
+}
diff --git a/crates/horizon-client/src/lang.rs b/crates/horizon-client-core/src/lang.rs
similarity index 90%
rename from crates/horizon-client/src/lang.rs
rename to crates/horizon-client-core/src/lang.rs
index cb96cc373..ad9f1a358 100644
--- a/crates/horizon-client/src/lang.rs
+++ b/crates/horizon-client-core/src/lang.rs
@@ -4,7 +4,10 @@
 //! language used by every screen.
 use std::{
     collections::{BTreeMap, HashMap},
-    sync::{Arc, RwLock},
+    sync::{
+        Arc, RwLock,
+        atomic::{AtomicBool, Ordering},
+    },
 };
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -23,11 +26,16 @@ impl LanguageInfo {
 #[derive(Default)]
 pub struct Language {
     pub code: String,
+    /// `LanguageInfo.bidirectional`: text without a strong character reads
+    /// right to left (`ClientLanguage.defaultRightToLeft`).
+    bidirectional: bool,
     map: HashMap<String, String>,
 }
 pub const DEFAULT: &str = "en_us";
 
 static CURRENT: RwLock<Option<Arc<Language>>> = RwLock::new(None);
+/// The current language's `bidirectional`, read for every drawn string.
+static BIDIRECTIONAL: AtomicBool = AtomicBool::new(false);
 
 /// A source of resource files: the prepared root plus packs, highest priority last.
 pub trait ResourceSource {
@@ -42,8 +50,12 @@ struct Bundled;
 impl ResourceSource for Bundled {
     fn read(&self, path: &str) -> Option<Vec<u8>> {
         let body = match path {
-            "assets/horizon/lang/en_us.json" => include_str!("../assets/horizon/lang/en_us.json"),
-            "assets/horizon/lang/ru_ru.json" => include_str!("../assets/horizon/lang/ru_ru.json"),
+            "assets/horizon/lang/en_us.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/en_us.json")
+            }
+            "assets/horizon/lang/ru_ru.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/ru_ru.json")
+            }
             _ => return None,
         };
         Some(body.as_bytes().to_vec())
@@ -130,8 +142,12 @@ impl Language {
         {
             apply_deprecated(&mut map, &bytes);
         }
+        let bidirectional = available(sources)
+            .iter()
+            .any(|info| info.code == code && info.bidirectional);
         Self {
             code: code.to_owned(),
+            bidirectional,
             map,
         }
     }
@@ -193,11 +209,16 @@ pub fn available(sources: &[&dyn ResourceSource]) -> Vec<LanguageInfo> {
 }
 
 pub fn set(language: Language) {
+    BIDIRECTIONAL.store(language.bidirectional, Ordering::Relaxed);
     *CURRENT.write().unwrap_or_else(|e| e.into_inner()) = Some(Arc::new(language));
 }
 pub fn current() -> Option<Arc<Language>> {
     CURRENT.read().unwrap_or_else(|e| e.into_inner()).clone()
 }
+/// `ClientLanguage.defaultRightToLeft` of the current language.
+pub fn bidirectional() -> bool {
+    BIDIRECTIONAL.load(Ordering::Relaxed)
+}
 pub fn code() -> String {
     current().map_or_else(|| DEFAULT.to_owned(), |l| l.code.clone())
 }
diff --git a/crates/horizon-client-core/src/lib.rs b/crates/horizon-client-core/src/lib.rs
new file mode 100644
index 000000000..7721668ca
--- /dev/null
+++ b/crates/horizon-client-core/src/lib.rs
@@ -0,0 +1,26 @@
+//! The client's lowest layer, below commands and gameplay: chat text and
+//! translations, SNBT and NBT paths, text components, the scoreboard, boss
+//! bars, game rules, block entity NBT tables, and the registry, particle and
+//! sound source tables commands name, and the `pack.mcmeta` filter regex.
+//! horizon-client re-exports each module under its old path
+//! (`horizon_client::text`, ...).
+#![forbid(unsafe_code)]
+pub mod block_entity_nbt;
+pub mod bossbar;
+pub mod component;
+pub mod fastutil_order;
+pub mod gamerules;
+pub mod identifier;
+pub mod key_display;
+pub mod lang;
+pub mod nbt_path;
+pub mod particle_type;
+pub mod pattern;
+pub mod potions;
+pub mod registries;
+pub mod scoreboard;
+pub mod snbt;
+pub mod sound_source;
+pub mod text;
+pub mod uuid;
+pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
diff --git a/crates/horizon-client/src/nbt_path.rs b/crates/horizon-client-core/src/nbt_path.rs
similarity index 100%
rename from crates/horizon-client/src/nbt_path.rs
rename to crates/horizon-client-core/src/nbt_path.rs
diff --git a/crates/horizon-client-core/src/particle_type.rs b/crates/horizon-client-core/src/particle_type.rs
new file mode 100644
index 000000000..98de2380b
--- /dev/null
+++ b/crates/horizon-client-core/src/particle_type.rs
@@ -0,0 +1,209 @@
+//! Particle types (`ParticleTypes`): the vanilla particle types with a client
+//! implementation, by registry name, and their per-type flags.
+
+macro_rules! particle_types {
+    ($($variant:ident = $name:literal),* $(,)?) => {
+        /// Vanilla particle types with a client implementation here.
+        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+        pub enum ParticleType { $($variant),* }
+        impl ParticleType {
+            pub const ALL: &'static [ParticleType] = &[$(ParticleType::$variant),*];
+            /// Registry path (`minecraft:<name>`), also the sprite-set file name.
+            pub fn name(self) -> &'static str {
+                match self { $(ParticleType::$variant => $name),* }
+            }
+            pub fn from_name(name: &str) -> Option<Self> {
+                let name = name.strip_prefix("minecraft:").unwrap_or(name);
+                match name { $($name => Some(ParticleType::$variant),)* _ => None }
+            }
+        }
+    };
+}
+particle_types! {
+    Block = "block",
+    BlockCrumble = "block_crumble",
+    Trail = "trail",
+    DustPillar = "dust_pillar",
+    FallingDust = "falling_dust",
+    Smoke = "smoke",
+    LargeSmoke = "large_smoke",
+    WhiteSmoke = "white_smoke",
+    Flame = "flame",
+    SoulFireFlame = "soul_fire_flame",
+    CopperFireFlame = "copper_fire_flame",
+    SmallFlame = "small_flame",
+    Lava = "lava",
+    DrippingWater = "dripping_water",
+    FallingWater = "falling_water",
+    DrippingLava = "dripping_lava",
+    FallingLava = "falling_lava",
+    LandingLava = "landing_lava",
+    DrippingHoney = "dripping_honey",
+    FallingHoney = "falling_honey",
+    LandingHoney = "landing_honey",
+    FallingNectar = "falling_nectar",
+    FallingSporeBlossom = "falling_spore_blossom",
+    SporeBlossomAir = "spore_blossom_air",
+    DrippingObsidianTear = "dripping_obsidian_tear",
+    FallingObsidianTear = "falling_obsidian_tear",
+    LandingObsidianTear = "landing_obsidian_tear",
+    DrippingDripstoneWater = "dripping_dripstone_water",
+    FallingDripstoneWater = "falling_dripstone_water",
+    DrippingDripstoneLava = "dripping_dripstone_lava",
+    FallingDripstoneLava = "falling_dripstone_lava",
+    Splash = "splash",
+    Rain = "rain",
+    Bubble = "bubble",
+    SulfurBubbles = "sulfur_bubbles",
+    BubblePop = "bubble_pop",
+    BubbleColumnUp = "bubble_column_up",
+    CurrentDown = "current_down",
+    Underwater = "underwater",
+    Portal = "portal",
+    ReversePortal = "reverse_portal",
+    Enchant = "enchant",
+    Nautilus = "nautilus",
+    VaultConnection = "vault_connection",
+    Crit = "crit",
+    EnchantedHit = "enchanted_hit",
+    DamageIndicator = "damage_indicator",
+    Heart = "heart",
+    AngryVillager = "angry_villager",
+    HappyVillager = "happy_villager",
+    Composter = "composter",
+    Mycelium = "mycelium",
+    Dolphin = "dolphin",
+    EggCrack = "egg_crack",
+    Poof = "poof",
+    Explosion = "explosion",
+    ExplosionEmitter = "explosion_emitter",
+    CampfireCosySmoke = "campfire_cosy_smoke",
+    CampfireSignalSmoke = "campfire_signal_smoke",
+    Note = "note",
+    Dust = "dust",
+    TotemOfUndying = "totem_of_undying",
+    Firework = "firework",
+    EndRod = "end_rod",
+    Ash = "ash",
+    WhiteAsh = "white_ash",
+    CrimsonSpore = "crimson_spore",
+    WarpedSpore = "warped_spore",
+    CherryLeaves = "cherry_leaves",
+    PaleOakLeaves = "pale_oak_leaves",
+    TintedLeaves = "tinted_leaves",
+    Effect = "effect",
+    InstantEffect = "instant_effect",
+    EntityEffect = "entity_effect",
+    Witch = "witch",
+    Infested = "infested",
+    Cloud = "cloud",
+    Sneeze = "sneeze",
+    Snowflake = "snowflake",
+    Soul = "soul",
+    SculkSoul = "sculk_soul",
+    DragonBreath = "dragon_breath",
+    Gust = "gust",
+    SmallGust = "small_gust",
+    GustEmitterLarge = "gust_emitter_large",
+    GustEmitterSmall = "gust_emitter_small",
+    DustColorTransition = "dust_color_transition",
+    SculkCharge = "sculk_charge",
+    SculkChargePop = "sculk_charge_pop",
+    Shriek = "shriek",
+    SonicBoom = "sonic_boom",
+    Vibration = "vibration",
+    SweepAttack = "sweep_attack",
+    Glow = "glow",
+    WaxOn = "wax_on",
+    WaxOff = "wax_off",
+    ElectricSpark = "electric_spark",
+    Scrape = "scrape",
+    SquidInk = "squid_ink",
+    GlowSquidInk = "glow_squid_ink",
+    Item = "item",
+    ItemSlime = "item_slime",
+    ItemSnowball = "item_snowball",
+    ItemCobweb = "item_cobweb",
+    SulfurCubeGoo = "sulfur_cube_goo",
+    Flash = "flash",
+    Firefly = "firefly",
+    TrialSpawnerDetection = "trial_spawner_detection",
+    TrialSpawnerDetectionOminous = "trial_spawner_detection_ominous",
+    TrialOmen = "trial_omen",
+    RaidOmen = "raid_omen",
+    OminousSpawning = "ominous_spawning",
+    Spit = "spit",
+    Fishing = "fishing",
+    DustPlume = "dust_plume",
+    RedPoplarLeaves = "red_poplar_leaves",
+    OrangePoplarLeaves = "orange_poplar_leaves",
+    YellowPoplarLeaves = "yellow_poplar_leaves",
+    PauseMobGrowth = "pause_mob_growth",
+    ResetMobGrowth = "reset_mob_growth",
+    BlockMarker = "block_marker",
+}
+impl ParticleType {
+    /// `ParticleType.getOverrideLimiter` (`ParticleTypes.register(name, true)`):
+    /// spawned regardless of distance.
+    pub fn override_limiter(self) -> bool {
+        matches!(
+            self,
+            Self::BlockMarker
+                | Self::DamageIndicator
+                | Self::ExplosionEmitter
+                | Self::Explosion
+                | Self::Gust
+                | Self::GustEmitterLarge
+                | Self::GustEmitterSmall
+                | Self::SonicBoom
+                | Self::SculkCharge
+                | Self::SculkChargePop
+                | Self::Vibration
+                | Self::Poof
+                | Self::Spit
+                | Self::SquidInk
+                | Self::SweepAttack
+                | Self::CampfireCosySmoke
+                | Self::CampfireSignalSmoke
+                | Self::GlowSquidInk
+                | Self::Glow
+                | Self::WaxOn
+                | Self::WaxOff
+                | Self::ElectricSpark
+                | Self::Scrape
+                | Self::TrialSpawnerDetection
+                | Self::TrialSpawnerDetectionOminous
+                | Self::VaultConnection
+                | Self::OminousSpawning
+        )
+    }
+    /// `SingleQuadParticle.Layer.translucent`: types whose vanilla particle class
+    /// hardcodes the translucent layer, drawn after translucent terrain.
+    /// `TerrainParticle`, `BreakingItemParticle` and `BlockMarker` resolve their
+    /// layer from the sprite instead (`Layer.bySprite`); see the `translucent`
+    /// sprite set on the engine.
+    pub fn translucent_layer(self) -> bool {
+        match self {
+            // CampfireSmokeParticle.
+            Self::CampfireCosySmoke | Self::CampfireSignalSmoke
+            // PlayerCloudParticle.
+            | Self::Cloud | Self::Sneeze
+            // SpellParticle.
+            | Self::Effect | Self::InstantEffect | Self::EntityEffect
+            | Self::Witch | Self::Infested | Self::TrialOmen | Self::RaidOmen
+            // EmissiveRisingParticle.
+            | Self::Soul | Self::SculkSoul
+            // SculkChargeParticle, SculkChargePopParticle, ShriekParticle,
+            // VibrationSignalParticle, FireflyParticle, OverlayParticle.
+            | Self::SculkCharge | Self::SculkChargePop | Self::Shriek
+            | Self::Vibration | Self::Firefly | Self::Flash
+            // SimpleAnimatedParticle and its subclasses: EndRodParticle,
+            // SparkParticle (firework), SquidInkParticle, TotemParticle.
+            | Self::EndRod | Self::Firework | Self::SquidInk | Self::GlowSquidInk
+            | Self::TotemOfUndying
+            // FlyTowardsPositionParticle: its LifetimeAlpha(0, 0.6, 0.25, 1) is not opaque.
+            | Self::VaultConnection => true,
+            _ => false,
+        }
+    }
+}
diff --git a/crates/horizon-client/src/packs/pattern.rs b/crates/horizon-client-core/src/pattern.rs
similarity index 100%
rename from crates/horizon-client/src/packs/pattern.rs
rename to crates/horizon-client-core/src/pattern.rs
diff --git a/crates/horizon-client-core/src/potions.rs b/crates/horizon-client-core/src/potions.rs
new file mode 100644
index 000000000..044b25e3a
--- /dev/null
+++ b/crates/horizon-client-core/src/potions.rs
@@ -0,0 +1,249 @@
+//! The `MobEffects` and `Potions` registries (code in vanilla, ported as
+//! tables): each effect's colour and category, each potion's effects, and the
+//! potion colour mix. horizon-client re-exports them from `brewing`.
+use std::{collections::HashMap, sync::OnceLock};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Category {
+    Beneficial,
+    Harmful,
+    Neutral,
+}
+/// A `MobEffect`: id (without namespace), colour, category, instantaneous.
+#[derive(Clone, Copy, Debug)]
+pub struct EffectDef {
+    pub id: &'static str,
+    pub color: u32,
+    pub category: Category,
+    pub instant: bool,
+}
+const fn fx(id: &'static str, color: u32, category: Category) -> EffectDef {
+    EffectDef {
+        id,
+        color,
+        category,
+        instant: false,
+    }
+}
+use Category::{Beneficial as B, Harmful as H, Neutral as N};
+/// `MobEffects` in registration order.
+pub const EFFECTS: &[EffectDef] = &[
+    fx("speed", 3402751, B),
+    fx("slowness", 9154528, H),
+    fx("haste", 14270531, B),
+    fx("mining_fatigue", 4866583, H),
+    fx("strength", 16762624, B),
+    EffectDef {
+        id: "instant_health",
+        color: 16262179,
+        category: B,
+        instant: true,
+    },
+    EffectDef {
+        id: "instant_damage",
+        color: 11101546,
+        category: H,
+        instant: true,
+    },
+    fx("jump_boost", 16646020, B),
+    fx("nausea", 5578058, H),
+    fx("regeneration", 13458603, B),
+    fx("resistance", 9520880, B),
+    fx("fire_resistance", 16750848, B),
+    fx("water_breathing", 10017472, B),
+    fx("invisibility", 16185078, B),
+    fx("blindness", 2039587, H),
+    fx("night_vision", 12779366, B),
+    fx("hunger", 5797459, H),
+    fx("weakness", 4738376, H),
+    fx("poison", 8889187, H),
+    fx("wither", 7561558, H),
+    fx("health_boost", 16284963, B),
+    fx("absorption", 2445989, B),
+    EffectDef {
+        id: "saturation",
+        color: 16262179,
+        category: B,
+        instant: true,
+    },
+    fx("glowing", 9740385, N),
+    fx("levitation", 13565951, H),
+    fx("luck", 5882118, B),
+    fx("unluck", 12624973, H),
+    fx("slow_falling", 15978425, B),
+    fx("conduit_power", 1950417, B),
+    fx("dolphins_grace", 8954814, B),
+    fx("bad_omen", 745784, N),
+    fx("hero_of_the_village", 4521796, B),
+    fx("darkness", 2696993, H),
+    fx("trial_omen", 1484454, N),
+    fx("raid_omen", 14565464, N),
+    fx("wind_charged", 12438015, H),
+    fx("weaving", 7891290, H),
+    fx("oozing", 10092451, H),
+    fx("infested", 9214860, H),
+    fx("breath_of_the_nautilus", 65518, B),
+];
+pub fn effect(id: &str) -> Option<&'static EffectDef> {
+    let id = id.trim_start_matches("minecraft:");
+    EFFECTS.iter().find(|e| e.id == id)
+}
+/// Namespaced effect ids for mob effect storage.
+pub fn namespaced(id: &'static str) -> &'static str {
+    static IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
+    IDS.get_or_init(|| {
+        EFFECTS
+            .iter()
+            .map(|e| {
+                (
+                    e.id,
+                    &*Box::leak(format!("minecraft:{}", e.id).into_boxed_str()),
+                )
+            })
+            .collect()
+    })
+    .get(id)
+    .copied()
+    .unwrap_or(id)
+}
+/// A `Potion`: id, name suffix (`item.minecraft.potion.effect.<name>`) and
+/// effects as (effect, duration ticks, amplifier).
+#[derive(Clone, Copy, Debug)]
+pub struct PotionDef {
+    pub id: &'static str,
+    pub name: &'static str,
+    pub effects: &'static [(&'static str, i32, i32)],
+}
+const fn p(
+    id: &'static str,
+    name: &'static str,
+    effects: &'static [(&'static str, i32, i32)],
+) -> PotionDef {
+    PotionDef { id, name, effects }
+}
+/// `Potions` in registration order.
+pub const POTIONS: &[PotionDef] = &[
+    p("water", "water", &[]),
+    p("mundane", "mundane", &[]),
+    p("thick", "thick", &[]),
+    p("awkward", "awkward", &[]),
+    p("night_vision", "night_vision", &[("night_vision", 3600, 0)]),
+    p(
+        "long_night_vision",
+        "night_vision",
+        &[("night_vision", 9600, 0)],
+    ),
+    p("invisibility", "invisibility", &[("invisibility", 3600, 0)]),
+    p(
+        "long_invisibility",
+        "invisibility",
+        &[("invisibility", 9600, 0)],
+    ),
+    p("leaping", "leaping", &[("jump_boost", 3600, 0)]),
+    p("long_leaping", "leaping", &[("jump_boost", 9600, 0)]),
+    p("strong_leaping", "leaping", &[("jump_boost", 1800, 1)]),
+    p(
+        "fire_resistance",
+        "fire_resistance",
+        &[("fire_resistance", 3600, 0)],
+    ),
+    p(
+        "long_fire_resistance",
+        "fire_resistance",
+        &[("fire_resistance", 9600, 0)],
+    ),
+    p("swiftness", "swiftness", &[("speed", 3600, 0)]),
+    p("long_swiftness", "swiftness", &[("speed", 9600, 0)]),
+    p("strong_swiftness", "swiftness", &[("speed", 1800, 1)]),
+    p("slowness", "slowness", &[("slowness", 1800, 0)]),
+    p("long_slowness", "slowness", &[("slowness", 4800, 0)]),
+    p("strong_slowness", "slowness", &[("slowness", 400, 3)]),
+    p(
+        "turtle_master",
+        "turtle_master",
+        &[("slowness", 400, 3), ("resistance", 400, 2)],
+    ),
+    p(
+        "long_turtle_master",
+        "turtle_master",
+        &[("slowness", 800, 3), ("resistance", 800, 2)],
+    ),
+    p(
+        "strong_turtle_master",
+        "turtle_master",
+        &[("slowness", 400, 5), ("resistance", 400, 3)],
+    ),
+    p(
+        "water_breathing",
+        "water_breathing",
+        &[("water_breathing", 3600, 0)],
+    ),
+    p(
+        "long_water_breathing",
+        "water_breathing",
+        &[("water_breathing", 9600, 0)],
+    ),
+    p("healing", "healing", &[("instant_health", 1, 0)]),
+    p("strong_healing", "healing", &[("instant_health", 1, 1)]),
+    p("harming", "harming", &[("instant_damage", 1, 0)]),
+    p("strong_harming", "harming", &[("instant_damage", 1, 1)]),
+    p("poison", "poison", &[("poison", 900, 0)]),
+    p("long_poison", "poison", &[("poison", 1800, 0)]),
+    p("strong_poison", "poison", &[("poison", 432, 1)]),
+    p("regeneration", "regeneration", &[("regeneration", 900, 0)]),
+    p(
+        "long_regeneration",
+        "regeneration",
+        &[("regeneration", 1800, 0)],
+    ),
+    p(
+        "strong_regeneration",
+        "regeneration",
+        &[("regeneration", 450, 1)],
+    ),
+    p("strength", "strength", &[("strength", 3600, 0)]),
+    p("long_strength", "strength", &[("strength", 9600, 0)]),
+    p("strong_strength", "strength", &[("strength", 1800, 1)]),
+    p("weakness", "weakness", &[("weakness", 1800, 0)]),
+    p("long_weakness", "weakness", &[("weakness", 4800, 0)]),
+    p("luck", "luck", &[("luck", 6000, 0)]),
+    p("slow_falling", "slow_falling", &[("slow_falling", 1800, 0)]),
+    p(
+        "long_slow_falling",
+        "slow_falling",
+        &[("slow_falling", 4800, 0)],
+    ),
+    p("wind_charged", "wind_charged", &[("wind_charged", 3600, 0)]),
+    p("weaving", "weaving", &[("weaving", 3600, 0)]),
+    p("oozing", "oozing", &[("oozing", 3600, 0)]),
+    p("infested", "infested", &[("infested", 3600, 0)]),
+];
+pub fn potion(id: &str) -> Option<&'static PotionDef> {
+    let id = id.trim_start_matches("minecraft:");
+    POTIONS.iter().find(|p| p.id == id)
+}
+/// `PotionContents.BASE_POTION_COLOR` (ARGB -13083194) as RGB.
+pub const BASE_POTION_COLOR: u32 = 0x385DC6;
+/// `PotionContents.getColor`: amplifier-weighted mix of visible effect colours.
+pub fn potion_color(id: Option<&str>) -> u32 {
+    let Some(def) = id.and_then(potion) else {
+        return BASE_POTION_COLOR;
+    };
+    let (mut r, mut g, mut b, mut total) = (0u32, 0u32, 0u32, 0u32);
+    for (e, _, amp) in def.effects {
+        let Some(e) = effect(e) else { continue };
+        let w = *amp as u32 + 1;
+        r += w * (e.color >> 16 & 255);
+        g += w * (e.color >> 8 & 255);
+        b += w * (e.color & 255);
+        total += w;
+    }
+    match (
+        r.checked_div(total),
+        g.checked_div(total),
+        b.checked_div(total),
+    ) {
+        (Some(r), Some(g), Some(b)) => (r << 16) | (g << 8) | b,
+        _ => BASE_POTION_COLOR,
+    }
+}
diff --git a/crates/horizon-client-core/src/registries.rs b/crates/horizon-client-core/src/registries.rs
new file mode 100644
index 000000000..310115cf8
--- /dev/null
+++ b/crates/horizon-client-core/src/registries.rs
@@ -0,0 +1,188 @@
+//! Registry contents and source state that commands validate and complete
+//! arguments against (what the server's registry access holds).
+use std::collections::BTreeMap;
+
+/// Registry contents and source state used to validate and complete arguments.
+#[derive(Clone, Debug, Default)]
+pub struct Registries {
+    /// Permission level of the command source.
+    pub permission: u8,
+    pub items: Vec<String>,
+    pub item_tags: Vec<String>,
+    /// Block id -> (property, allowed values).
+    pub blocks: BTreeMap<String, Vec<(String, Vec<String>)>>,
+    pub block_tags: Vec<String>,
+    /// Entity types that `summon` can create.
+    pub summonable: Vec<String>,
+    /// Every entity type (selector `type=`).
+    pub entity_types: Vec<String>,
+    pub effects: Vec<String>,
+    pub enchantments: Vec<String>,
+    pub structures: Vec<String>,
+    pub biomes: Vec<String>,
+    pub dimensions: Vec<String>,
+    pub clocks: Vec<String>,
+    pub timelines: Vec<String>,
+    pub time_markers: Vec<String>,
+    pub advancements: Vec<String>,
+    /// Game rule name -> integer-valued.
+    pub game_rules: Vec<(String, bool)>,
+    pub players: Vec<String>,
+    /// Scoreboard objective names, team names and tracked score holders.
+    pub objectives: Vec<String>,
+    pub teams: Vec<String>,
+    pub tracked: Vec<String>,
+    /// Loaded datapack functions (`ns:path`) and function tags (`ns:path`).
+    pub functions: Vec<String>,
+    /// `/data ... storage` ids.
+    pub storages: Vec<String>,
+    /// Boss bar ids and datapack predicate ids.
+    pub bossbars: Vec<String>,
+    pub predicates: Vec<String>,
+    pub item_modifiers: Vec<String>,
+    pub schedules: Vec<String>,
+    pub stopwatches: Vec<String>,
+    pub recipes: Vec<String>,
+    pub sounds: Vec<String>,
+    pub damage_types: Vec<String>,
+    pub attributes: Vec<String>,
+    pub loot_tables: Vec<String>,
+    pub templates: Vec<String>,
+    pub random_sequences: Vec<String>,
+    pub datapacks_enabled: Vec<String>,
+    pub datapacks_disabled: Vec<String>,
+    pub function_tags: Vec<String>,
+    /// The block the source is looking at (relevant coordinates).
+    pub target_block: Option<[i32; 3]>,
+    /// Every registry's element and tag ids (`minecraft:item` -> ...), as
+    /// the server's registry access and reloadable registries hold them.
+    pub by_registry: BTreeMap<String, RegistryIds>,
+    /// Blocks whose default state has a block entity.
+    pub block_entities: std::collections::BTreeSet<String>,
+    /// Block tag -> member blocks.
+    pub block_tag_members: BTreeMap<String, Vec<String>>,
+    /// Data component types with a codec (not transient).
+    pub persistent_components: Vec<String>,
+    /// Recipes `/recipe` can give (not special).
+    pub learnable_recipes: Vec<String>,
+    /// Advancement id -> criterion names.
+    pub advancement_criteria: BTreeMap<String, Vec<String>>,
+    /// World clock -> time markers shown in commands.
+    pub clock_time_markers: BTreeMap<String, Vec<String>>,
+    /// Trigger objectives the source may use (`/trigger` suggestions).
+    pub trigger_objectives: Vec<String>,
+    /// Objectives with the `trigger` criterion -> holder -> whether its score is locked.
+    pub trigger_scores: BTreeMap<String, BTreeMap<String, bool>>,
+}
+/// The ids and tag ids of one registry.
+#[derive(Clone, Debug, Default)]
+pub struct RegistryIds {
+    pub ids: Vec<String>,
+    pub tags: Vec<String>,
+}
+const EMPTY: &[String] = &[];
+impl Registries {
+    /// Fill what the game did not build itself from vanilla's exported
+    /// registries (`command-registries.json`, written by
+    /// `VanillaCommandParseOracle registries`): built-in registries such as
+    /// mob effects, data component types and dialogs, block entities and tag
+    /// members. Registries that data packs reload stay with the game.
+    pub fn fill_from_export(&mut self, r: &serde_json::Value) {
+        fn strings(v: &serde_json::Value) -> Vec<String> {
+            v.as_array()
+                .map(|a| {
+                    a.iter()
+                        .filter_map(|x| x.as_str().map(str::to_owned))
+                        .collect()
+                })
+                .unwrap_or_default()
+        }
+        let fill = |field: &mut Vec<String>, key: &str| {
+            if field.is_empty() {
+                *field = strings(&r[key]);
+            }
+        };
+        fill(&mut self.effects, "effects");
+        fill(&mut self.enchantments, "enchantments");
+        fill(&mut self.attributes, "attributes");
+        fill(&mut self.damage_types, "damage_types");
+        fill(&mut self.templates, "templates");
+        fill(&mut self.persistent_components, "persistent_components");
+        fill(&mut self.learnable_recipes, "learnable_recipes");
+        const RELOADED: [&str; 5] = [
+            "minecraft:advancement",
+            "minecraft:recipe",
+            "minecraft:loot_table",
+            "minecraft:predicate",
+            "minecraft:item_modifier",
+        ];
+        for (name, entry) in r["by_registry"].as_object().into_iter().flatten() {
+            if RELOADED.contains(&name.as_str()) || self.by_registry.contains_key(name) {
+                continue;
+            }
+            self.by_registry.insert(
+                name.clone(),
+                RegistryIds {
+                    ids: strings(&entry["ids"]),
+                    tags: strings(&entry["tags"]),
+                },
+            );
+        }
+        if self.block_entities.is_empty() {
+            self.block_entities = strings(&r["block_entities"]).into_iter().collect();
+        }
+        if self.block_tag_members.is_empty() {
+            for (tag, members) in r["block_tag_members"].as_object().into_iter().flatten() {
+                self.block_tag_members.insert(tag.clone(), strings(members));
+            }
+        }
+        if self.clock_time_markers.is_empty() {
+            for (clock, markers) in r["clock_time_markers"].as_object().into_iter().flatten() {
+                self.clock_time_markers
+                    .insert(clock.clone(), strings(markers));
+            }
+        }
+        if self.advancement_criteria.is_empty() {
+            for (id, criteria) in r["advancement_criteria"].as_object().into_iter().flatten() {
+                self.advancement_criteria
+                    .insert(id.clone(), strings(criteria));
+            }
+        }
+    }
+    /// The element ids of a registry (sorted).
+    pub fn ids(&self, registry: &str) -> &[String] {
+        if let Some(r) = self.by_registry.get(registry) {
+            return &r.ids;
+        }
+        match registry {
+            "minecraft:item" => &self.items,
+            "minecraft:entity_type" => &self.entity_types,
+            "minecraft:mob_effect" => &self.effects,
+            "minecraft:enchantment" => &self.enchantments,
+            "minecraft:worldgen/structure" => &self.structures,
+            "minecraft:worldgen/biome" => &self.biomes,
+            "minecraft:world_clock" => &self.clocks,
+            "minecraft:timeline" => &self.timelines,
+            "minecraft:attribute" => &self.attributes,
+            "minecraft:damage_type" => &self.damage_types,
+            "minecraft:sound_event" => &self.sounds,
+            "minecraft:predicate" => &self.predicates,
+            "minecraft:item_modifier" => &self.item_modifiers,
+            "minecraft:loot_table" => &self.loot_tables,
+            "minecraft:recipe" => &self.recipes,
+            "minecraft:advancement" => &self.advancements,
+            _ => EMPTY,
+        }
+    }
+    /// The tag ids of a registry (sorted).
+    pub fn tags(&self, registry: &str) -> &[String] {
+        if let Some(r) = self.by_registry.get(registry) {
+            return &r.tags;
+        }
+        match registry {
+            "minecraft:item" => &self.item_tags,
+            "minecraft:block" => &self.block_tags,
+            _ => EMPTY,
+        }
+    }
+}
diff --git a/crates/horizon-client/src/scoreboard.rs b/crates/horizon-client-core/src/scoreboard.rs
similarity index 99%
rename from crates/horizon-client/src/scoreboard.rs
rename to crates/horizon-client-core/src/scoreboard.rs
index 4796be51a..3e820e4eb 100644
--- a/crates/horizon-client/src/scoreboard.rs
+++ b/crates/horizon-client-core/src/scoreboard.rs
@@ -2,9 +2,9 @@
 //! `ObjectiveCriteria`, `NumberFormat`) and its saved data
 //! (`data/minecraft/scoreboard.dat`, `ScoreboardSaveData.Packed`).
 use crate::{
-    command::Registries,
     component,
     fastutil_order::{HashSetOrder, OpenOrder},
+    registries::Registries,
     text::{self, Style, Text},
 };
 use horizon_world::nbt::Tag;
@@ -1266,7 +1266,7 @@ fn entity_uuids(tag: &mut Tag) {
                             })
                             .collect::<Option<Vec<i32>>>(),
                         Tag::String(s) => {
-                            crate::save::uuid_from_text(&s.to_string_lossy()).map(Vec::from)
+                            crate::uuid::uuid_from_text(&s.to_string_lossy()).map(Vec::from)
                         }
                         _ => None,
                     };
diff --git a/crates/horizon-client/src/snbt.rs b/crates/horizon-client-core/src/snbt.rs
similarity index 100%
rename from crates/horizon-client/src/snbt.rs
rename to crates/horizon-client-core/src/snbt.rs
diff --git a/crates/horizon-client-core/src/sound_source.rs b/crates/horizon-client-core/src/sound_source.rs
new file mode 100644
index 000000000..d181d6ac5
--- /dev/null
+++ b/crates/horizon-client-core/src/sound_source.rs
@@ -0,0 +1,7 @@
+//! Sound sources (`SoundSource`), by name.
+
+/// SoundSource names in vanilla order.
+pub const SOUND_SOURCES: [&str; 11] = [
+    "master", "music", "record", "weather", "block", "hostile", "neutral", "player", "ambient",
+    "voice", "ui",
+];
diff --git a/crates/horizon-client/src/text.rs b/crates/horizon-client-core/src/text.rs
similarity index 98%
rename from crates/horizon-client/src/text.rs
rename to crates/horizon-client-core/src/text.rs
index 4c04c9da5..3a0bf301b 100644
--- a/crates/horizon-client/src/text.rs
+++ b/crates/horizon-client-core/src/text.rs
@@ -42,6 +42,10 @@ pub fn named_color(name: &str) -> Option<u32> {
 /// Click actions carried by locally constructed text components.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum ClickEvent {
+    /// `ClickEvent.OpenUrl`: an http or https link.
+    OpenUrl(String),
+    /// `ClickEvent.ChangePage`: a book's page, counted from 1.
+    ChangePage(i32),
     SuggestCommand(String),
     CopyToClipboard(String),
     /// A local file to open with the system handler.
@@ -67,7 +71,7 @@ pub struct Style {
 }
 /// A style's `font` field: an identifier (`alt` is `minecraft:alt`).
 pub fn font_id(v: &Value) -> Option<String> {
-    crate::command::args::parse_identifier(v.as_str()?)
+    crate::identifier::parse_identifier(v.as_str()?)
 }
 impl Style {
     pub fn color(c: u32) -> Self {
@@ -529,6 +533,8 @@ fn style_json(style: &Style) -> Vec<(String, Value)> {
     }
     if let Some(click) = &style.click {
         let event = match click {
+            ClickEvent::OpenUrl(url) => json!({ "action": "open_url", "url": url }),
+            ClickEvent::ChangePage(page) => json!({ "action": "change_page", "page": page }),
             ClickEvent::SuggestCommand(command) => {
                 json!({ "action": "suggest_command", "command": command })
             }
diff --git a/crates/horizon-client-core/src/uuid.rs b/crates/horizon-client-core/src/uuid.rs
new file mode 100644
index 000000000..4ede9b141
--- /dev/null
+++ b/crates/horizon-client-core/src/uuid.rs
@@ -0,0 +1,24 @@
+//! UUIDs as vanilla's four-int form, to and from their text form.
+
+pub fn uuid_text(u: [i32; 4]) -> String {
+    let hex: String = u.iter().map(|v| format!("{:08x}", *v as u32)).collect();
+    format!(
+        "{}-{}-{}-{}-{}",
+        &hex[0..8],
+        &hex[8..12],
+        &hex[12..16],
+        &hex[16..20],
+        &hex[20..32]
+    )
+}
+pub fn uuid_from_text(s: &str) -> Option<[i32; 4]> {
+    let hex: String = s.chars().filter(|c| *c != '-').collect();
+    if hex.len() != 32 {
+        return None;
+    }
+    let mut out = [0i32; 4];
+    for (i, v) in out.iter_mut().enumerate() {
+        *v = u32::from_str_radix(&hex[i * 8..i * 8 + 8], 16).ok()? as i32;
+    }
+    Some(out)
+}
diff --git a/crates/horizon-client/Cargo.toml b/crates/horizon-client/Cargo.toml
index f1011c534..150433918 100644
--- a/crates/horizon-client/Cargo.toml
+++ b/crates/horizon-client/Cargo.toml
@@ -9,6 +9,8 @@ description = "Horizon native development client"
 
 [dependencies]
 horizon-assets = { path = "../horizon-assets" }
+horizon-client-core = { path = "../horizon-client-core" }
+horizon-command = { path = "../horizon-command" }
 horizon-core = { path = "../horizon-core" }
 # The server thread ahead of the workers (MinecraftServer.spin's Thread.setPriority).
 horizon-threads = { path = "../horizon-threads" }
@@ -60,6 +62,7 @@ gilrs = { version = "0.11", optional = true }
 horizon-dualsense = { path = "../horizon-dualsense", optional = true }
 # HTTPS to the Minecraft services (online-mode session join).
 ureq = { version = "2", default-features = false, features = ["tls"] }
+unicode-bidi = "0.3.18"
 
 [target.'cfg(unix)'.dependencies]
 # The server thread's CPU time per tick (`HORIZON_SPIKES`, spans.rs).
diff --git a/crates/horizon-client/examples/probe/arrow_probe.rs b/crates/horizon-client/examples/probe/arrow_probe.rs
index f72e6276e..411561c4e 100644
--- a/crates/horizon-client/examples/probe/arrow_probe.rs
+++ b/crates/horizon-client/examples/probe/arrow_probe.rs
@@ -163,6 +163,8 @@ pub fn main() -> Result<()> {
                                     ArrowSound::HitGround => "hit",
                                     ArrowSound::Splash => "splash",
                                     ArrowSound::Extinguish => "extinguish",
+                                    ArrowSound::TridentHitGround => "trident_hit_ground",
+                                    ArrowSound::TridentHit => "trident_hit",
                                 },
                                 volume.to_bits(),
                                 pitch.to_bits()
diff --git a/crates/horizon-client/examples/probe/entity_anim_fixture.rs b/crates/horizon-client/examples/probe/entity_anim_fixture.rs
index 4aceb9f6f..4582033fe 100644
--- a/crates/horizon-client/examples/probe/entity_anim_fixture.rs
+++ b/crates/horizon-client/examples/probe/entity_anim_fixture.rs
@@ -592,6 +592,7 @@ pub fn main() -> horizon_client::Result<()> {
                     pose,
                     num("maxCrossbowChageDuration"),
                     num("ticksUsingItem"),
+                    false,
                 );
             }
             Species::Evoker | Species::Illusioner | Species::Pillager | Species::Vindicator => {
diff --git a/crates/horizon-client/examples/probe/entity_death_loot_fixture.rs b/crates/horizon-client/examples/probe/entity_death_loot_fixture.rs
index 86ef275d9..3f47ba787 100644
--- a/crates/horizon-client/examples/probe/entity_death_loot_fixture.rs
+++ b/crates/horizon-client/examples/probe/entity_death_loot_fixture.rs
@@ -23,6 +23,7 @@ fn stack(spec: &str) -> LootStack {
         map: false,
         exploration: None,
         ominous_amplifier: None,
+        stew_effects: Vec::new(),
     };
     for e in parts {
         let (name, level) = e.rsplit_once(':').unwrap_or((e, "1"));
diff --git a/crates/horizon-client/examples/probe/finalize_spawn_fixture.rs b/crates/horizon-client/examples/probe/finalize_spawn_fixture.rs
index b1b25e723..067d545a8 100644
--- a/crates/horizon-client/examples/probe/finalize_spawn_fixture.rs
+++ b/crates/horizon-client/examples/probe/finalize_spawn_fixture.rs
@@ -154,11 +154,11 @@ const MEMORIES: [&str; 7] = [
 fn variant(m: &Mob, regs: &SpawnRegistries, v: &mut Vec<String>) {
     use Species as S;
     let s = m.species();
-    let named = |reg: &finalize::VariantRegistry, i: u8| {
-        format!(
-            "minecraft:{}",
+    let named = |reg: &finalize::VariantRegistry, i: Option<u8>| {
+        let name = i.map_or("classic", |i| {
             reg.names.get(i as usize).map_or("?", |n| n.as_str())
-        )
+        });
+        format!("minecraft:{name}")
     };
     let var = format!("minecraft:{}", finalize::variant_name(s, m.extra.variant));
     match s {
diff --git a/crates/horizon-client/examples/probe/mob_ai_probe.rs b/crates/horizon-client/examples/probe/mob_ai_probe.rs
index ecdf02901..07f2bf22a 100644
--- a/crates/horizon-client/examples/probe/mob_ai_probe.rs
+++ b/crates/horizon-client/examples/probe/mob_ai_probe.rs
@@ -580,7 +580,7 @@ fn player_hurt(player: Option<&PlayerView>, e: &MobEvent) -> bool {
     match e {
         MobEvent::AttackPlayer(amount, _) | MobEvent::DamagePlayer { amount, .. } => *amount > 0.0,
         // ServerExplosion.hurtEntities: within twice the radius every hit does damage.
-        MobEvent::Explode(at, radius) => {
+        MobEvent::Explode(at, radius, _) => {
             let d = Vec3::new(at[0], at[1], at[2])
                 .distance_squared(p.position)
                 .sqrt();
@@ -1050,6 +1050,7 @@ pub fn main() -> horizon_client::Result<()> {
                 off_hand: None,
                 head: None,
                 armor_cover: 0.0,
+                invisible: false,
                 spectator: false,
                 gold_armor: false,
                 hurt_by: None,
@@ -1057,9 +1058,11 @@ pub fn main() -> horizon_client::Result<()> {
                 velocity: Vec3::ZERO,
                 yaw: 0.0,
                 hero: false,
+                effects: Vec::new(),
                 uuid: PLAYER_UUID,
                 allies: Default::default(),
                 remote: false,
+                passenger: false,
             }
         });
         let mut scratch = LegacyRandom::new(0);
@@ -1069,6 +1072,8 @@ pub fn main() -> horizon_client::Result<()> {
         for (i, m) in mobs.iter().enumerate() {
             print(&mut out, 0, i, m, s.creative, world.game_time);
         }
+        // No player has a chest open in the scenarios.
+        let lid_openers = std::collections::HashMap::new();
         // The MobWorld every step sees, over a snapshot of the mobs.
         macro_rules! mob_world {
             ($snapshot:expr) => {
@@ -1080,6 +1085,7 @@ pub fn main() -> horizon_client::Result<()> {
                     world: &world,
                     registry,
                     facts: &facts,
+                    fluid_tables: &motion.fluids,
                     movement: &motion.blocks,
                     collision: &collision,
                     data: &data,
@@ -1097,12 +1103,14 @@ pub fn main() -> horizon_client::Result<()> {
                     block_tags: &items.block_tags,
                     biomes: &biomes,
                     mob_griefing: true,
+                    mob_drops: true,
                     difficulty: LocalDifficulty::new(s.difficulty, world.day_time, 0, 0.0),
                     end: false,
                     world_seed: 0,
                     // FlatLevelSource.getSeaLevel.
                     sea_level: -63,
                     items: Some(&items),
+                    lid_openers: &lid_openers,
                 }
             };
         }
diff --git a/crates/horizon-client/examples/probe/recipe_book_fixture.rs b/crates/horizon-client/examples/probe/recipe_book_fixture.rs
index ce2afe624..2dda3b109 100644
--- a/crates/horizon-client/examples/probe/recipe_book_fixture.rs
+++ b/crates/horizon-client/examples/probe/recipe_book_fixture.rs
@@ -5,6 +5,10 @@
 //!
 //! usage: recipe_book_fixture RESOURCES CASES OUTPUT
 use horizon_client::recipe_book::{BookType, RecipeIndex, Settings};
+use horizon_protocol::{
+    buf::{Codec, Reader, Writer},
+    packets::recipes::RecipeBookChangeSettings,
+};
 use horizon_world::nbt::Tag;
 use serde_json::Value;
 use std::{collections::BTreeSet, fs, path::Path};
@@ -93,8 +97,23 @@ pub fn main() -> horizon_client::Result<()> {
                         _ => BookType::Smoker,
                     }
                     .index();
-                    book.open[i] = op["open"].as_bool().unwrap_or(false);
-                    book.filtering[i] = op["filtering"].as_bool().unwrap_or(false);
+                    let packet = RecipeBookChangeSettings {
+                        book_type: i as i32,
+                        open: op["open"].as_bool().unwrap_or(false),
+                        filtering: op["filtering"].as_bool().unwrap_or(false),
+                    };
+                    let mut wire = Writer::new();
+                    RecipeBookChangeSettings::write(&packet, &mut wire);
+                    extra = format!(
+                        " packet={}",
+                        wire.data
+                            .iter()
+                            .map(|b| format!("{b:02x}"))
+                            .collect::<String>()
+                    );
+                    let decoded = RecipeBookChangeSettings::read(&mut Reader::new(&wire.data))?;
+                    book.open[decoded.book_type as usize] = decoded.open;
+                    book.filtering[decoded.book_type as usize] = decoded.filtering;
                 }
                 "save" => {
                     let tag = book.write();
diff --git a/crates/horizon-client/examples/probe/scene_motion_probe.rs b/crates/horizon-client/examples/probe/scene_motion_probe.rs
index 21977eeab..0a7e4b594 100644
--- a/crates/horizon-client/examples/probe/scene_motion_probe.rs
+++ b/crates/horizon-client/examples/probe/scene_motion_probe.rs
@@ -164,6 +164,8 @@ fn snapshot(out: &mut impl Write, player: &PlayerMotion) -> Result<()> {
         .iter()
         .filter_map(|e| match e {
             MotionEvent::Fall(e) => Some(e.trace()),
+            // The oracle's player wears no armor; the game applies this one.
+            MotionEvent::Health(horizon_client::health::HealthEvent::ArmorHurt { .. }) => None,
             MotionEvent::Health(e) => Some(e.trace()),
             MotionEvent::Snowflake { position, velocity } => Some(format!(
                 "snowflake {:016x},{:016x},{:016x} {:016x},{:016x},{:016x}",
@@ -351,6 +353,7 @@ pub fn main() -> Result<()> {
                             horizon_world::food::Difficulty::Hard,
                         ][op["difficulty"].as_u64().unwrap() as usize],
                         natural_regeneration: op["regenerate"].as_bool().unwrap(),
+                        ..Default::default()
                     };
                 }
                 "food" => {
diff --git a/crates/horizon-client/src/advancements.rs b/crates/horizon-client/src/advancements.rs
index 6706532b7..1ed11da4d 100644
--- a/crates/horizon-client/src/advancements.rs
+++ b/crates/horizon-client/src/advancements.rs
@@ -437,6 +437,8 @@ pub struct EntityView {
     /// mainhand, offhand, head, chest, legs, feet, body.
     pub equipment: [Option<ItemView>; 7],
     pub vehicle: Option<Box<EntityView>>,
+    /// Player: what it looks at within 100 blocks (`PlayerPredicate.lookingAt`).
+    pub looking_at: Option<Box<EntityView>>,
     pub effects: Vec<(String, i32, i32)>,
     /// Player: game mode name.
     pub gamemode: Option<String>,
@@ -458,7 +460,7 @@ fn range_f(v: &Value, x: f64) -> bool {
         _ => false,
     }
 }
-fn range_i(v: &Value, x: i64) -> bool {
+pub fn range_i(v: &Value, x: i64) -> bool {
     range_f(v, x as f64)
 }
 /// A registry id, `#tag`, or list matched against one id.
@@ -473,6 +475,51 @@ pub fn id_matches(v: &Value, registry: &str, id: &str, w: &dyn World) -> bool {
         _ => false,
     }
 }
+/// `PotionsPredicate`: the potion in a `HolderSet`, plus a `CollectionPredicate`
+/// over the potion's effects (`contains`, `count`, `size`).
+pub fn potions(v: &Value, potion: Option<&str>, w: &dyn World) -> bool {
+    if v.is_null() {
+        return true;
+    }
+    if !v["potions"].is_null() && !potion.is_some_and(|p| id_matches(&v["potions"], "potion", p, w))
+    {
+        return false;
+    }
+    let c = &v["effects"];
+    if c.is_null() {
+        return true;
+    }
+    let effects: Vec<(String, i32, i32)> = potion
+        .and_then(crate::brewing::potion)
+        .map(|d| {
+            d.effects
+                .iter()
+                .map(|(id, dur, amp)| (format!("minecraft:{id}"), *amp, *dur))
+                .collect()
+        })
+        .unwrap_or_default();
+    // `MobEffectsPredicate.test`: the one listed effect, amplifier and duration.
+    let test = |pred: &Value, e: &(String, i32, i32)| {
+        pred.as_object().is_some_and(|m| {
+            m.get(&e.0).is_some_and(|want| {
+                range_i(&want["amplifier"], i64::from(e.1))
+                    && range_i(&want["duration"], i64::from(e.2))
+                    && want["ambient"].as_bool().is_none_or(|b| !b)
+                    && want["visible"].as_bool().is_none_or(|b| b)
+            })
+        })
+    };
+    c["contains"]
+        .as_array()
+        .is_none_or(|l| l.iter().all(|p| effects.iter().any(|e| test(p, e))))
+        && c["count"].as_array().is_none_or(|l| {
+            l.iter().all(|entry| {
+                let n = effects.iter().filter(|e| test(&entry["test"], e)).count();
+                range_i(&entry["count"], n as i64)
+            })
+        })
+        && range_i(&c["size"], effects.len() as i64)
+}
 /// `ItemPredicate`.
 pub fn item(v: &Value, it: &ItemView, w: &dyn World) -> bool {
     if v.is_null() {
@@ -614,6 +661,18 @@ fn components(expected: &Value, have: &[(String, String)]) -> bool {
         })
     })
 }
+/// `DistancePredicate.matches` between two points.
+pub fn distance(v: &Value, a: [f64; 3], b: [f64; 3]) -> bool {
+    let d = [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+    range_f(&v["x"], d[0].abs())
+        && range_f(&v["y"], d[1].abs())
+        && range_f(&v["z"], d[2].abs())
+        && range_f(&v["horizontal"], (d[0] * d[0] + d[2] * d[2]).sqrt())
+        && range_f(
+            &v["absolute"],
+            (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt(),
+        )
+}
 /// `EntityPredicate` (26.x keyed sub-predicates).
 pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> bool {
     if v.is_null() {
@@ -629,21 +688,7 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo
             "minecraft:stepping_on" => {
                 location(p, [e.position[0], e.position[1] - 0.5, e.position[2]], w)
             }
-            "minecraft:distance" | "distance" => {
-                let d = [
-                    e.position[0] - origin[0],
-                    e.position[1] - origin[1],
-                    e.position[2] - origin[2],
-                ];
-                range_f(&p["x"], d[0].abs())
-                    && range_f(&p["y"], d[1].abs())
-                    && range_f(&p["z"], d[2].abs())
-                    && range_f(&p["horizontal"], (d[0] * d[0] + d[2] * d[2]).sqrt())
-                    && range_f(
-                        &p["absolute"],
-                        (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt(),
-                    )
-            }
+            "minecraft:distance" | "distance" => distance(p, e.position, origin),
             "minecraft:flags" | "flags" => {
                 let f = |k: &str, have: bool| p[k].as_bool().is_none_or(|want| want == have);
                 f("is_on_fire", e.on_fire)
@@ -678,11 +723,16 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo
                     })
                 })
             }),
-            "minecraft:type_specific/player" => p["gamemode"].as_array().is_none_or(|modes| {
-                e.gamemode
-                    .as_deref()
-                    .is_some_and(|g| modes.iter().any(|m| m.as_str() == Some(g)))
-            }),
+            "minecraft:type_specific/player" => {
+                p["gamemode"].as_array().is_none_or(|modes| {
+                    e.gamemode
+                        .as_deref()
+                        .is_some_and(|g| modes.iter().any(|m| m.as_str() == Some(g)))
+                }) && (p["looking_at"].is_null()
+                    || e.looking_at
+                        .as_ref()
+                        .is_some_and(|t| entity(&p["looking_at"], t, w, origin)))
+            }
             "minecraft:type_specific/lightning" => {
                 range_i(&p["blocks_set_on_fire"], 0)
                     && (p["entity_struck"].is_null()
@@ -703,6 +753,52 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo
     }
     true
 }
+/// A damage event as `DamagePredicate` sees it.
+#[derive(Clone, Debug, Default)]
+pub struct DamageView {
+    /// The damage type id (`minecraft:arrow`).
+    pub kind: String,
+    /// `DamageSource.getDirectEntity` and `getEntity`.
+    pub direct: Option<EntityView>,
+    pub source: Option<EntityView>,
+    /// `DamageSource.isDirect`: the direct entity is the causing one.
+    pub is_direct: bool,
+    /// The damage before and after the shield took its share.
+    pub original: f32,
+    pub actual: f32,
+    pub blocked: bool,
+}
+/// `DamagePredicate`, with its `DamageSourcePredicate` as `type`.
+pub fn damage(v: &Value, d: &DamageView, w: &dyn World, origin: [f64; 3]) -> bool {
+    if v.is_null() {
+        return true;
+    }
+    let by = |key: &str, e: &Option<EntityView>| {
+        v[key].is_null() || e.as_ref().is_some_and(|e| entity(&v[key], e, w, origin))
+    };
+    if !range_f(&v["dealt"], f64::from(d.original))
+        || !range_f(&v["taken"], f64::from(d.actual))
+        || !by("source_entity", &d.source)
+        || v["blocked"].as_bool().is_some_and(|b| b != d.blocked)
+    {
+        return false;
+    }
+    let ty = &v["type"];
+    let tags_ok = ty["tags"].as_array().into_iter().flatten().all(|t| {
+        let tag = t["id"].as_str().unwrap_or("");
+        let tag = tag.strip_prefix('#').unwrap_or(tag);
+        w.in_tag("damage_type", tag, &d.kind) == t["expected"].as_bool().unwrap_or(true)
+    });
+    let direct_ok = ty["direct_entity"].is_null()
+        || d.direct
+            .as_ref()
+            .is_some_and(|e| entity(&ty["direct_entity"], e, w, origin));
+    let source_ok = ty["source_entity"].is_null()
+        || d.source
+            .as_ref()
+            .is_some_and(|e| entity(&ty["source_entity"], e, w, origin));
+    tags_ok && direct_ok && source_ok && ty["is_direct"].as_bool().is_none_or(|b| b == d.is_direct)
+}
 /// The entities a loot-style condition list may refer to.
 pub struct Entities<'a> {
     pub this: Option<&'a EntityView>,
diff --git a/crates/horizon-client/src/animate_tick.rs b/crates/horizon-client/src/animate_tick.rs
index 28b28544b..c2123e693 100644
--- a/crates/horizon-client/src/animate_tick.rs
+++ b/crates/horizon-client/src/animate_tick.rs
@@ -35,8 +35,10 @@ enum Animate {
     Campfire {
         spawn_particles: bool,
     },
-    /// Leaves: optional falling-leaf particle and chance, tinted by foliage.
-    Leaves(Option<(T, f32)>),
+    /// Leaves: optional falling-leaf particle and chance; a tinted leaf takes
+    /// the biome foliage colour unless a fixed colour is given (azalea); and
+    /// whether they have the poplar ambient sound (`AmbientLeavesBlockSoundPlayer`).
+    Leaves(Option<(T, f32)>, Option<u32>, bool),
     NetherPortal,
     EnchantingTable,
     EndRod([i32; 3]),
@@ -47,8 +49,11 @@ enum Animate {
     CandleCake,
     BrewingStand,
     EnderChest,
-    /// FallingBlock with its dust colour.
-    Falling(u32),
+    /// FallingBlock with its dust colour; sand also has the ambient desert sound
+    /// (`SandBlock.animateTick`).
+    Falling(u32, bool),
+    /// A beehive or bee nest full of honey (`BeehiveBlock.animateTick`).
+    Beehive,
     RedstoneOre,
     RedstoneWire {
         power: u8,
@@ -70,6 +75,8 @@ enum Animate {
         waterlogged: bool,
     },
     EndPortal,
+    /// `WetSpongeBlock.animateTick`.
+    WetSponge,
 }
 fn step(facing: &str) -> [i32; 3] {
     match facing {
@@ -104,10 +111,17 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
             spawn_particles: false,
         },
         "oak_leaves" | "birch_leaves" | "jungle_leaves" | "acacia_leaves" | "dark_oak_leaves"
-        | "mangrove_leaves" => Animate::Leaves(Some((T::TintedLeaves, 0.01))),
-        "cherry_leaves" => Animate::Leaves(Some((T::CherryLeaves, 0.1))),
-        "pale_oak_leaves" => Animate::Leaves(Some((T::PaleOakLeaves, 0.02))),
-        "spruce_leaves" | "azalea_leaves" | "flowering_azalea_leaves" => Animate::Leaves(None),
+        | "mangrove_leaves" => Animate::Leaves(Some((T::TintedLeaves, 0.01)), None, false),
+        "cherry_leaves" => Animate::Leaves(Some((T::CherryLeaves, 0.1)), None, false),
+        "pale_oak_leaves" => Animate::Leaves(Some((T::PaleOakLeaves, 0.02)), None, false),
+        "red_poplar_leaves" => Animate::Leaves(Some((T::RedPoplarLeaves, 0.01)), None, true),
+        "orange_poplar_leaves" => Animate::Leaves(Some((T::OrangePoplarLeaves, 0.01)), None, true),
+        "yellow_poplar_leaves" => Animate::Leaves(Some((T::YellowPoplarLeaves, 0.01)), None, true),
+        // The azalea blocks drop tinted leaves of the fixed colour -9399763.
+        "azalea_leaves" | "flowering_azalea_leaves" => {
+            Animate::Leaves(Some((T::TintedLeaves, 0.01)), Some(0x0070_922D), false)
+        }
+        "spruce_leaves" => Animate::Leaves(None, None, false),
         "nether_portal" => Animate::NetherPortal,
         "enchanting_table" => Animate::EnchantingTable,
         "end_rod" => Animate::EndRod(facing()),
@@ -116,9 +130,18 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
         "mycelium" => Animate::Mycelium,
         "brewing_stand" => Animate::BrewingStand,
         "ender_chest" => Animate::EnderChest,
-        "sand" => Animate::Falling(0xDBD3A0),
-        "red_sand" => Animate::Falling(0xA95821),
-        "gravel" => Animate::Falling(0x807C7B),
+        "sand" => Animate::Falling(0xDBD3A0, true),
+        "red_sand" => Animate::Falling(0xA95821, true),
+        "gravel" => Animate::Falling(0x807C7B, false),
+        // AnvilBlock/ConcretePowderBlock.getDustColor is the map colour;
+        // DragonEggBlock's is black.
+        "anvil" | "chipped_anvil" | "damaged_anvil" => Animate::Falling(0xA7A7A7, false),
+        "dragon_egg" => Animate::Falling(0x000000, false),
+        _ if name.ends_with("_concrete_powder") => Animate::Falling(
+            concrete_powder_color(name.trim_end_matches("_concrete_powder")),
+            false,
+        ),
+        "beehive" | "bee_nest" if prop("honey_level").as_deref() == Some("5") => Animate::Beehive,
         "redstone_ore" | "deepslate_redstone_ore" if lit => Animate::RedstoneOre,
         "redstone_wire" => {
             let power = prop("power").and_then(|p| p.parse().ok()).unwrap_or(0);
@@ -149,6 +172,10 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
             waterlogged: prop("waterlogged").as_deref() == Some("true"),
         },
         "end_portal" => Animate::EndPortal,
+        "wet_sponge" => Animate::WetSponge,
+        // BrushableBlock has no dust colour of its own, so the dust is the map colour.
+        "suspicious_sand" => Animate::Falling(0xF7E9A3, false),
+        "suspicious_gravel" => Animate::Falling(0x707070, false),
         "sculk_sensor" | "calibrated_sculk_sensor"
             if prop("sculk_sensor_phase").as_deref() == Some("active") =>
         {
@@ -161,6 +188,27 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
         _ => Animate::None,
     }
 }
+/// `DyeColor.getMapColor` of a concrete powder colour.
+fn concrete_powder_color(dye: &str) -> u32 {
+    match dye {
+        "white" => 0xFFFFFF,
+        "orange" => 0xD87F33,
+        "magenta" => 0xB24CD8,
+        "light_blue" => 0x6699D8,
+        "yellow" => 0xE5E533,
+        "lime" => 0x7FCC19,
+        "pink" => 0xF27FA5,
+        "gray" => 0x4C4C4C,
+        "light_gray" => 0x999999,
+        "cyan" => 0x4C7F99,
+        "purple" => 0x7F3FB2,
+        "blue" => 0x334CB2,
+        "brown" => 0x664C33,
+        "green" => 0x667F33,
+        "red" => 0x993333,
+        _ => 0x191919,
+    }
+}
 /// `RedstoneWireBlock.COLORS`.
 fn redstone_color(power: u8) -> [f32; 3] {
     let f = f32::from(power) / 15.0;
@@ -194,6 +242,10 @@ pub struct AnimateTables {
     power_transmitter: Vec<bool>,
     /// `#triggers_ambient_dried_ghast_block_sounds` (soul sand, soul soil).
     dried_ghast_sounds: Vec<bool>,
+    /// `#triggers_ambient_desert_sand_block_sounds` (sand, red sand).
+    desert_sand_sounds: Vec<bool>,
+    /// `#required_for_poplar_leaf_ambience` (overworld natural logs).
+    poplar_leaf_logs: Vec<bool>,
     /// `FireBlock.canBurn`: states with ignite odds above zero (none waterlogged).
     burnable: Vec<bool>,
     /// Biome id -> ambient particles and probabilities (`minecraft:visual/ambient_particles`).
@@ -269,6 +321,8 @@ impl AnimateTables {
             power_provider: by_state("minecraft:enchantment_power_provider"),
             power_transmitter: by_state("minecraft:enchantment_power_transmitter"),
             dried_ghast_sounds: by_state("minecraft:triggers_ambient_dried_ghast_block_sounds"),
+            desert_sand_sounds: by_state("minecraft:triggers_ambient_desert_sand_block_sounds"),
+            poplar_leaf_logs: by_state("minecraft:required_for_poplar_leaf_ambience"),
             burnable,
             ambient,
         })
@@ -357,6 +411,10 @@ impl AnimateContext<'_> {
 fn add(engine: &mut ParticleEngine, ty: T, p: [f64; 3], v: [f64; 3]) {
     engine.add(&ParticleOptions::simple(ty), p, v);
 }
+/// `Level.addAlwaysVisibleParticle`: still shown under the Minimal option now and then.
+fn add_visible(engine: &mut ParticleEngine, ty: T, p: [f64; 3], v: [f64; 3]) {
+    engine.add_with(&ParticleOptions::simple(ty), p, v, false, true);
+}
 fn sound(engine: &mut ParticleEngine, name: &'static str, p: [f64; 3], volume: f32, pitch: f32) {
     engine.sounds.push((name, p, volume, pitch));
 }
@@ -504,6 +562,53 @@ fn try_spawn_drip(
         }
     }
 }
+/// `BeehiveBlock.trySpawnDripParticles`.
+fn beehive_drip(
+    tables: &AnimateTables,
+    engine: &mut ParticleEngine,
+    ctx: &AnimateContext,
+    state: BlockStateId,
+    pos: [i32; 3],
+) {
+    if ctx.facts.get(state).fluid != Fluid::None || engine.random().next_float() < 0.3 {
+        return;
+    }
+    let Some((bottom, top, bounds)) = ctx.shape_y(pos) else {
+        return;
+    };
+    if top < 1.0
+        || tables
+            .impermeable
+            .get(state.0 as usize)
+            .copied()
+            .unwrap_or(false)
+    {
+        return;
+    }
+    let y = if bottom > 0.0 {
+        f64::from(pos[1]) + bottom - 0.05
+    } else {
+        let below = [pos[0], pos[1] - 1, pos[2]];
+        let below_top = ctx.shape_y(below).map_or(1.0, |s| s.1);
+        // `belowTop < 1 || !isCollisionShapeFullBlock` and no fluid below.
+        if (below_top < 1.0 || !ctx.sturdy(below))
+            && ctx.facts.get(ctx.state(below)).fluid == Fluid::None
+        {
+            f64::from(pos[1]) - 0.05
+        } else {
+            return;
+        }
+    };
+    let r = engine.random();
+    let (a, b) = (r.next_double(), r.next_double());
+    let (fx, fz) = (f64::from(pos[0]), f64::from(pos[2]));
+    let p = [
+        fx + bounds[0] + (bounds[1] - bounds[0]) * a,
+        y,
+        fz + bounds[2] + (bounds[3] - bounds[2]) * b,
+    ];
+    add(engine, T::DrippingHoney, p, [0.0; 3]);
+}
 /// `WaterFluid.animateTick` / `LavaFluid.animateTick`.
 fn fluid_animate_tick(
     engine: &mut ParticleEngine,
@@ -685,7 +790,7 @@ fn block_animate_tick(
                 }
             }
         }
-        Animate::Leaves(falling) => {
+        Animate::Leaves(falling, fixed_tint, poplar) => {
             let below = [pos[0], pos[1] - 1, pos[2]];
             // LeavesBlock.makeDrippingWaterParticles.
             if (ctx.raining_at)([pos[0], pos[1] + 1, pos[2]]) && next_int(engine.random(), 15) == 1
@@ -697,6 +802,9 @@ fn block_animate_tick(
                     add(engine, T::DrippingWater, p, [0.0; 3]);
                 }
             }
+            if poplar {
+                leaves_ambient_sound(tables, engine, ctx, state, pos);
+            }
             // FallingParticlesLeavesBlock.makeFallingLeavesParticles.
             if let Some((ty, chance)) = falling
                 && engine.random().next_float() < chance
@@ -705,7 +813,7 @@ fn block_animate_tick(
                 let r = engine.random();
                 let p = [fx + r.next_double(), fy - 0.05, fz + r.next_double()];
                 let options = if ty == T::TintedLeaves {
-                    let c = ctx.foliage(pos);
+                    let c = fixed_tint.unwrap_or_else(|| ctx.foliage(pos));
                     let f = |s: u32| ((c >> s) & 255) as f32 / 255.0;
                     ParticleOptions::colored(ty, [f(16), f(8), f(0), 1.0])
                 } else {
@@ -869,7 +977,7 @@ fn block_animate_tick(
                         fy + 1.0 + f64::from(r.next_float()),
                         fz + f64::from(r.next_float()),
                     ];
-                    add(engine, T::SulfurBubbles, p, [0.0; 3]);
+                    add_visible(engine, T::SulfurBubbles, p, [0.0; 3]);
                 }
                 if next_int(engine.random(), 10) == 0 {
                     let name = "minecraft:block.potent_sulfur.noxious_gas";
@@ -877,6 +985,36 @@ fn block_animate_tick(
                 }
             }
         }
+        Animate::WetSponge => {
+            // Direction.getRandom: DOWN, UP, NORTH, SOUTH, WEST, EAST.
+            const DIRECTIONS: [[i32; 3]; 6] = [
+                [0, -1, 0],
+                [0, 1, 0],
+                [0, 0, -1],
+                [0, 0, 1],
+                [-1, 0, 0],
+                [1, 0, 0],
+            ];
+            let d = DIRECTIONS[next_int(engine.random(), 6) as usize];
+            // The sponge occludes, so only a sturdy neighbour face hides the drip.
+            if d != [0, 1, 0] && !ctx.sturdy([pos[0] + d[0], pos[1] + d[1], pos[2] + d[2]]) {
+                let r = engine.random();
+                let p = match d {
+                    [0, -1, 0] => [fx + r.next_double(), fy - 0.05, fz + r.next_double()],
+                    [dx, _, 0] => {
+                        let y = fy + r.next_double() * 0.8;
+                        let z = fz + r.next_double();
+                        [fx + if dx > 0 { 1.1 } else { 0.05 }, y, z]
+                    }
+                    [_, _, dz] => {
+                        let y = fy + r.next_double() * 0.8;
+                        let x = fx + r.next_double();
+                        [x, y, fz + if dz > 0 { 1.1 } else { 0.05 }]
+                    }
+                };
+                add(engine, T::DrippingWater, p, [0.0; 3]);
+            }
+        }
         Animate::Mycelium => {
             let r = engine.random();
             if next_int(r, 10) == 0 {
@@ -959,7 +1097,7 @@ fn block_animate_tick(
                 add(engine, T::Portal, p, v);
             }
         }
-        Animate::Falling(color) => {
+        Animate::Falling(color, sand) => {
             if next_int(engine.random(), 16) == 0 {
                 let below = ctx.facts.get(ctx.state([pos[0], pos[1] - 1, pos[2]]));
                 // FallingBlock.isFree: air, fire, liquids or replaceable.
@@ -976,6 +1114,21 @@ fn block_animate_tick(
                     );
                 }
             }
+            // AmbientDesertBlockSoundsPlayer.playAmbientSandSounds: only for the air block.
+            if sand
+                && ctx.state([pos[0], pos[1] + 1, pos[2]]) == ctx.world.air
+                && next_int(engine.random(), 2100) == 0
+                && sand_sound_nearby(tables, ctx, pos)
+            {
+                sound(engine, "minecraft:block.sand.idle", [fx, fy, fz], 1.0, 1.0);
+            }
+        }
+        Animate::Beehive => {
+            // BeehiveBlock.animateTick: nextInt(1) + 1 attempts.
+            let attempts = next_int(engine.random(), 1) + 1;
+            for _ in 0..attempts {
+                beehive_drip(tables, engine, ctx, state, pos);
+            }
         }
         Animate::RedstoneOre => {
             for d in [
@@ -1086,7 +1239,7 @@ fn block_animate_tick(
         }
         Animate::BubbleColumn { drag } => {
             if drag {
-                add(engine, T::CurrentDown, [fx + 0.5, fy + 0.8, fz], [0.0; 3]);
+                add_visible(engine, T::CurrentDown, [fx + 0.5, fy + 0.8, fz], [0.0; 3]);
                 let r = engine.random();
                 if next_int(r, 200) == 0 {
                     let (volume, pitch) = (0.2 + r.next_float() * 0.2, 0.9 + r.next_float() * 0.15);
@@ -1099,7 +1252,7 @@ fn block_animate_tick(
                     );
                 }
             } else {
-                add(
+                add_visible(
                     engine,
                     T::BubbleColumnUp,
                     [fx + 0.5, fy, fz + 0.5],
@@ -1111,7 +1264,7 @@ fn block_animate_tick(
                     fy + f64::from(r.next_float()),
                     fz + f64::from(r.next_float()),
                 ];
-                add(engine, T::BubbleColumnUp, p, [0.0, 0.04, 0.0]);
+                add_visible(engine, T::BubbleColumnUp, p, [0.0, 0.04, 0.0]);
                 let r = engine.random();
                 if next_int(r, 200) == 0 {
                     let (volume, pitch) = (0.2 + r.next_float() * 0.2, 0.9 + r.next_float() * 0.15);
@@ -1189,6 +1342,91 @@ fn block_animate_tick(
         }
     }
 }
+/// `AmbientLeavesBlockSoundPlayer.playAmbientLeavesSounds` for the poplar leaves:
+/// one log and three leaves of the same kind around the block.
+fn leaves_ambient_sound(
+    tables: &AnimateTables,
+    engine: &mut ParticleEngine,
+    ctx: &AnimateContext,
+    state: BlockStateId,
+    pos: [i32; 3],
+) {
+    if next_int(engine.random(), 300) != 0 {
+        return;
+    }
+    let Some(name) = ctx.registry.state(state).map(|s| &s.name) else {
+        return;
+    };
+    let (mut logs, mut leaves) = (0, 0);
+    for d in [[0, -1], [1, 0], [0, 1], [-1, 0]] {
+        let neighbor = ctx.state([pos[0] + d[0], pos[1], pos[2] + d[1]]);
+        if tables
+            .poplar_leaf_logs
+            .get(neighbor.0 as usize)
+            .copied()
+            .unwrap_or(false)
+        {
+            logs += 1;
+        }
+        if ctx
+            .registry
+            .state(neighbor)
+            .is_some_and(|s| &s.name == name)
+        {
+            leaves += 1;
+        }
+        if logs == 1 && leaves == 3 {
+            let p = pos.map(f64::from);
+            sound(engine, "minecraft:block.poplar_leaves.ambient", p, 1.0, 1.0);
+            return;
+        }
+    }
+}
+/// `AmbientDesertBlockSoundsPlayer.shouldPlayAmbientSandSound`: sand in the
+/// surface column eight blocks away on all four sides.
+fn sand_sound_nearby(tables: &AnimateTables, ctx: &AnimateContext, pos: [i32; 3]) -> bool {
+    let is_sand = |p: [i32; 3]| {
+        tables
+            .desert_sand_sounds
+            .get(ctx.state(p).0 as usize)
+            .copied()
+            .unwrap_or(false)
+    };
+    let (mut found, mut checked) = (0, 0);
+    for d in [[0, -8], [8, 0], [0, 8], [-8, 0]] {
+        let (x, z) = (pos[0] + d[0], pos[2] + d[1]);
+        // columnContainsTriggeringBlock.
+        let surface = ctx.world.world_surface(x, z, |s| ctx.facts.is_air(s)) - 1;
+        let matches = if (surface - pos[1]).abs() > 5 {
+            let mut y = pos[1] + 6;
+            let mut above_air = ctx.is_air([x, y, z]);
+            y -= 1;
+            let mut hit = false;
+            for _ in 0..10 {
+                if above_air && is_sand([x, y, z]) {
+                    hit = true;
+                    break;
+                }
+                above_air = ctx.is_air([x, y, z]);
+                y -= 1;
+            }
+            hit
+        } else {
+            ctx.is_air([x, surface + 1, z]) && is_sand([x, surface, z])
+        };
+        if matches {
+            found += 1;
+            if found > 3 {
+                return true;
+            }
+        }
+        checked += 1;
+        if 4 - checked + found < 3 {
+            return false;
+        }
+    }
+    false
+}
 /// `AbstractCandleBlock.addParticlesAndSound`.
 fn candle(engine: &mut ParticleEngine, p: [f64; 3]) {
     let r = engine.random();
@@ -1209,21 +1447,32 @@ fn candle(engine: &mut ParticleEngine, p: [f64; 3]) {
     }
     add(engine, T::SmallFlame, p, [0.0; 3]);
 }
-/// `CampfireBlockEntity.particleTick` for every lit campfire (no cooking items).
+/// `CampfireBlockEntity.particleTick` for every lit campfire; `cooking` says
+/// which of a campfire's four slots hold an item.
 pub fn campfire_particles<'a>(
     tables: &AnimateTables,
     engine: &mut ParticleEngine,
     ctx: &AnimateContext,
     blocks: impl Iterator<Item = &'a ([i32; 3], u32)>,
+    cooking: &dyn Fn([i32; 3]) -> [bool; 4],
 ) {
     for &(pos, state) in blocks {
         if !tables.is_lit_campfire(state) {
             continue;
         }
-        let signal = ctx
+        let properties = ctx
             .registry
             .state(BlockStateId(state))
-            .is_some_and(|s| s.properties.get("signal_fire").map(String::as_str) == Some("true"));
+            .map(|s| &s.properties);
+        let prop = |k: &str| properties.and_then(|p| p.get(k)).map(String::as_str);
+        let signal = prop("signal_fire") == Some("true");
+        // Direction.get2DDataValue: south, west, north, east.
+        let rotation = match prop("facing") {
+            Some("west") => 1,
+            Some("north") => 2,
+            Some("east") => 3,
+            _ => 0,
+        };
         let r = engine.random();
         if r.next_float() < 0.11 {
             let count = next_int(r, 2) + 2;
@@ -1231,6 +1480,28 @@ pub fn campfire_particles<'a>(
                 make_campfire_smoke(engine, pos, signal, false);
             }
         }
+        // The smoke over each cooking item, at the slot's corner of the fire.
+        let occupied = cooking(pos);
+        for (slot, _) in occupied.iter().enumerate().filter(|(_, held)| **held) {
+            if engine.random().next_float() >= 0.2 {
+                continue;
+            }
+            // Direction.from2DDataValue((slot + rotation) % 4) and its clockwise side.
+            let (step, clockwise) = match (slot + rotation) % 4 {
+                0 => ([0.0, 1.0], [-1.0, 0.0]),
+                1 => ([-1.0, 0.0], [0.0, -1.0]),
+                2 => ([0.0, -1.0], [1.0, 0.0]),
+                _ => ([1.0, 0.0], [0.0, 1.0]),
+            };
+            let at = [
+                f64::from(pos[0]) + 0.5 - step[0] * 0.3125 + clockwise[0] * 0.3125,
+                f64::from(pos[1]) + 0.5,
+                f64::from(pos[2]) + 0.5 - step[1] * 0.3125 + clockwise[1] * 0.3125,
+            ];
+            for _ in 0..4 {
+                add(engine, T::Smoke, at, [0.0, 5.0e-4, 0.0]);
+            }
+        }
     }
 }
 /// `CampfireBlock.makeParticles` (always visible, overriding the limiter);
diff --git a/crates/horizon-client/src/arrows.rs b/crates/horizon-client/src/arrows.rs
index 30b501011..6d8dc528b 100644
--- a/crates/horizon-client/src/arrows.rs
+++ b/crates/horizon-client/src/arrows.rs
@@ -9,7 +9,7 @@ use crate::{
     collisions::SceneCollisions,
     mobs::Who,
     motion::{FluidResources, LAVA, WATER},
-    projectiles::{Hit, Projectile},
+    projectiles::{Hit, Projectile, ProjectileKind},
     world::World,
 };
 use horizon_core::{
@@ -132,6 +132,10 @@ pub enum ArrowSound {
     HitGround,
     /// `entity.generic.extinguish_fire`.
     Extinguish,
+    /// A thrown trident's `getDefaultHitGroundSoundEvent` (`item.trident.hit_ground`).
+    TridentHitGround,
+    /// `ThrownTrident.onHitEntity`'s `item.trident.hit`.
+    TridentHit,
 }
 /// What a burning arrow does to the block it hits (`onProjectileHit`).
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -156,7 +160,11 @@ pub struct ArrowState {
     /// `pickupItemStack`: what picking the arrow up gives.
     pub pickup_item: crate::items::ItemStack,
     pub no_physics: bool,
+    /// `AbstractArrow.getPierceLevel`.
     pub pierce: u8,
+    /// `piercingIgnoreEntityIds`: the entities a piercing arrow has gone
+    /// through (cleared when it sticks in a block).
+    pub pierced: Vec<Who>,
     /// `Entity.remainingFireTicks`.
     pub fire_ticks: i32,
     pub fall_distance: f64,
@@ -165,6 +173,9 @@ pub struct ArrowState {
     pub was_eye_in_water: bool,
     pub first_tick: bool,
     pub has_been_shot: bool,
+    /// `ThrownTrident.dealtDamage`: it has hit an entity (or sat in a block
+    /// for over 4 ticks) and hits no more.
+    pub dealt_damage: bool,
     pub removed: bool,
     /// The arrow's own random (`Entity.random`).
     pub random: LegacyRandom,
@@ -199,6 +210,7 @@ impl ArrowState {
             pickup_item: crate::items::ItemStack::new("minecraft:arrow", 1),
             no_physics: false,
             pierce: 0,
+            pierced: Vec::new(),
             fire_ticks: 0,
             fall_distance: 0.0,
             fluids: EntityFluidInteraction::new([WATER, LAVA]),
@@ -206,6 +218,7 @@ impl ArrowState {
             was_eye_in_water: false,
             first_tick: true,
             has_been_shot: false,
+            dealt_damage: false,
             removed: false,
             random,
             events: Vec::new(),
@@ -362,6 +375,29 @@ fn bounds(at: Vec3) -> Aabb {
         Vec3::new(at.x + w, at.y + f64::from(HEIGHT), at.z + w),
     )
 }
+/// The bounding box of an arrow, or a thrown trident, at `at`.
+pub fn arrow_bounds(at: Vec3) -> Aabb {
+    bounds(at)
+}
+/// The blocks an arrow that moved from `from` to `to` was inside
+/// (`Entity.checkInsideBlocks`: the sweep of its box, 16 steps at most), for
+/// the blocks that react to it (`entityInside`).
+pub fn blocks_inside(from: Vec3, to: Vec3) -> Vec<BlockPos> {
+    let deflated = bounds(to).deflate(Vec3::new(
+        f64::from(1.0e-5f32),
+        f64::from(1.0e-5f32),
+        f64::from(1.0e-5f32),
+    ));
+    let mut inside = Vec::new();
+    let _ = sweep_intersected_blocks(from, to, deflated, 1_000_000, |p, iteration| {
+        if iteration >= 16 {
+            return false;
+        }
+        inside.push(p);
+        true
+    });
+    inside
+}
 /// `Projectile.lerpRotation`.
 fn lerp_rotation(mut old: f32, new: f32) -> f32 {
     while new - old < -180.0 {
@@ -423,18 +459,29 @@ pub fn finish_entity_hit(p: &mut Projectile, scene: &ArrowScene, outcome: Entity
     let Some(mut st) = p.arrow.take() else {
         return false;
     };
+    let trident = matches!(p.kind, ProjectileKind::Trident);
     let mut ticker = Ticker {
         p,
         st: &mut st,
         scene,
     };
     match outcome {
+        EntityHit::Hurt | EntityHit::Refused if trident => ticker.trident_bounce(),
         EntityHit::Hurt => {
             ticker.hit_sound();
-            ticker.st.removed = true;
+            // A piercing arrow flies on (`getPierceLevel() <= 0` discards).
+            if ticker.st.pierce == 0 {
+                ticker.st.removed = true;
+            }
         }
         EntityHit::Refused => ticker.turn_back(),
-        EntityHit::Deflected => {}
+        EntityHit::Deflected => {
+            // The deflection comes before `onHitEntity` adds the entity to
+            // `piercingIgnoreEntityIds`.
+            if ticker.st.pierce > 0 {
+                ticker.st.pierced.pop();
+            }
+        }
     }
     ticker.finish();
     p.stuck = st.in_ground;
@@ -464,7 +511,16 @@ impl Ticker<'_, '_, '_, '_> {
                 p.z,
             ))
     }
+    /// Whether this is a `ThrownTrident` (`AbstractArrow` with its own water
+    /// inertia, sounds and hit).
+    fn trident(&self) -> bool {
+        matches!(self.p.kind, ProjectileKind::Trident)
+    }
     fn tick(&mut self, targets: &[(Who, Aabb)]) -> Hit {
+        // ThrownTrident.tick.
+        if self.trident() && self.st.in_ground_time > 4 {
+            self.st.dealt_damage = true;
+        }
         let physics = !self.st.no_physics;
         let movement = self.p.velocity;
         let block_pos = self.block_position();
@@ -512,8 +568,9 @@ impl Ticker<'_, '_, '_, '_> {
         self.st.in_ground_time = 0;
         let original = self.position();
         if self.st.was_touching_water {
-            // getWaterInertia, then the bubbles behind it.
-            self.p.velocity = self.p.velocity.scale(f64::from(0.6f32));
+            // getWaterInertia (0.99 for a trident), then the bubbles behind it.
+            let inertia = if self.trident() { 0.99f32 } else { 0.6f32 };
+            self.p.velocity = self.p.velocity.scale(f64::from(inertia));
             let v = self.p.velocity;
             for _ in 0..4 {
                 self.st.events.push(ArrowEvent::Particle {
@@ -639,7 +696,8 @@ impl Ticker<'_, '_, '_, '_> {
         self.st.life = 0;
     }
     /// `AbstractArrow.stepMoveAndHit`: the nearest entity on the way, else the
-    /// block (piercing is not modelled).
+    /// block. A piercing arrow that hits an entity here goes on from it next
+    /// tick (`finish_entity_hit`); vanilla's loop goes on within the same tick.
     fn step_move_and_hit(&mut self, from: Vec3, to: Vec3, targets: &[(Who, Aabb)]) -> Hit {
         let block = self.scene.clip(from, to);
         let end = block.map_or(to, |b| b.0);
@@ -649,10 +707,16 @@ impl Ticker<'_, '_, '_, '_> {
             .expand_towards(self.p.velocity)
             .inflate(Vec3::new(1.0, 1.0, 1.0));
         let mut best: Option<(Who, Vec3, f64)> = None;
+        // ThrownTrident.findHitEntity: none once it has dealt damage.
+        let targets = if self.st.dealt_damage { &[] } else { targets };
         for (who, b) in targets {
             if Some(*who) == self.p.owner && !self.p.left_owner || !b.intersects(area) {
                 continue;
             }
+            // canHitEntity: not an entity a piercing arrow has gone through.
+            if self.st.pierced.contains(who) {
+                continue;
+            }
             if let Some(at) = self.entity_hit(b, from, end, margin) {
                 // Sorted by the distance to the entity's position (the
                 // stable sort keeps the first of equals).
@@ -667,6 +731,15 @@ impl Ticker<'_, '_, '_, '_> {
         self.p.position = next;
         self.apply_effects_from_blocks(from, next);
         if let Some((who, at, _)) = best {
+            // AbstractArrow.onHitEntity: past pierce level + 1 entities the
+            // arrow is discarded before it hurts the next one.
+            if self.st.pierce > 0 {
+                if self.st.pierced.len() > usize::from(self.st.pierce) {
+                    self.st.removed = true;
+                    return Hit::None;
+                }
+                self.st.pierced.push(who);
+            }
             return Hit::Entity { who, at };
         }
         let Some((at, pos, face)) = block else {
@@ -706,12 +779,33 @@ impl Ticker<'_, '_, '_, '_> {
     /// `playSound(soundEvent, 1, 1.2 / (random * 0.2 + 0.9))`.
     fn hit_sound(&mut self) {
         let pitch = 1.2 / (self.st.random.next_float() * 0.2 + 0.9);
+        let sound = if self.trident() {
+            ArrowSound::TridentHitGround
+        } else {
+            ArrowSound::HitGround
+        };
         self.st.events.push(ArrowEvent::Sound {
-            sound: ArrowSound::HitGround,
+            sound,
             volume: 1.0,
             pitch,
         });
     }
+    /// `ThrownTrident.onHitEntity` after the hurt, whether it landed or not:
+    /// the hit sound, then `deflect(REVERSE, ..., (0.02, 0.2, 0.02))`. The
+    /// trident keeps flying (it has dealt its damage) and falls.
+    fn trident_bounce(&mut self) {
+        self.st.dealt_damage = true;
+        self.st.events.push(ArrowEvent::Sound {
+            sound: ArrowSound::TridentHit,
+            volume: 1.0,
+            pitch: 1.0,
+        });
+        // ProjectileDeflection.REVERSE.
+        let rotation = 170.0 + self.st.random.next_float() * 20.0;
+        let v = self.p.velocity;
+        self.p.velocity = Vec3::new(v.x * (-0.02 * 0.5), v.y * (-0.2 * 0.5), v.z * (-0.02 * 0.5));
+        self.p.yaw += rotation;
+    }
     /// `onHitEntity` when the entity took no damage: `deflect(REVERSE, 0.2)`,
     /// a half turn give or take ten degrees at a tenth of the speed; one
     /// left almost still drops its pickup (ALLOWED) and is discarded.
@@ -752,6 +846,7 @@ impl Ticker<'_, '_, '_, '_> {
         self.st.shake = 7;
         self.p.set_critical(false);
         self.st.pierce = 0;
+        self.st.pierced.clear();
     }
     /// `Projectile.mayInteract`: a mob's arrows need `mob_griefing`.
     fn may_interact(&self) -> bool {
diff --git a/crates/horizon-client/src/atlas_sources.rs b/crates/horizon-client/src/atlas_sources.rs
index 1eea24666..fbed22fd2 100644
--- a/crates/horizon-client/src/atlas_sources.rs
+++ b/crates/horizon-client/src/atlas_sources.rs
@@ -3,8 +3,8 @@
 //! `filter`, `unstitch` and `paletted_permutations` sources run in order
 //! against the resource tree; a later source replaces an earlier sprite of
 //! the same id and a filter removes the matching ones.
-use crate::packs::pattern::Pattern;
 use horizon_assets::palette::apply_palette;
+use horizon_client_core::pattern::Pattern;
 use serde_json::Value;
 use std::{
     collections::BTreeMap,
diff --git a/crates/horizon-client/src/audio.rs b/crates/horizon-client/src/audio.rs
index be6628ece..e45362e19 100644
--- a/crates/horizon-client/src/audio.rs
+++ b/crates/horizon-client/src/audio.rs
@@ -719,11 +719,6 @@ impl Audio {
         self.play(event, at, volume, pitch);
         self.capture = capture;
     }
-    /// `LivingEntity.handleDamageEvent`'s pitch, `(r - r) * 0.2 + 1`, drawn on the
-    /// client (the entity's own random there, never the server's world random).
-    pub fn hurt_pitch(&mut self) -> f32 {
-        (self.random.next_float() - self.random.next_float()) * 0.2 + 1.0
-    }
     /// `AbstractWidget.playButtonClickSound`: an unseeded, relative UI sound.
     pub fn play_button_click(&mut self) {
         self.play_instance(
diff --git a/crates/horizon-client/src/auth.rs b/crates/horizon-client/src/auth.rs
index b899ea5d5..a86992735 100644
--- a/crates/horizon-client/src/auth.rs
+++ b/crates/horizon-client/src/auth.rs
@@ -179,7 +179,7 @@ fn agent() -> ureq::Agent {
 }
 
 /// The discovery document, fetched once per game (a failure is retried next time).
-fn discovery() -> Result<Arc<serde_json::Value>, JoinError> {
+pub(crate) fn discovery() -> Result<Arc<serde_json::Value>, JoinError> {
     static CACHE: Mutex<Option<Arc<serde_json::Value>>> = Mutex::new(None);
     if let Some(d) = CACHE.lock().unwrap().clone() {
         return Ok(d);
diff --git a/crates/horizon-client/src/benchmark.rs b/crates/horizon-client/src/benchmark.rs
index 12e38e78a..bd2e97be0 100644
--- a/crates/horizon-client/src/benchmark.rs
+++ b/crates/horizon-client/src/benchmark.rs
@@ -450,6 +450,54 @@ mod tests {
         assert_eq!(view_chunks(32), 2573);
         assert_eq!(view_chunks(0), 0);
     }
+    /// The status a fake control answers with: the player is where it should
+    /// be, nothing is queued, and the world holds `chunks` resident chunks.
+    fn status(chunks: u64) -> String {
+        serde_json::json!({
+            "player": {"position": [0.0, 64.0, 0.0]},
+            "pending_chunks": 0,
+            "screen": "playing",
+            "render_distance": 12,
+            "chunks": chunks,
+            "generated_chunks": chunks,
+            "meshed_sections": 0,
+            "streaming": {},
+        })
+        .to_string()
+    }
+
+    #[test]
+    fn the_load_waits_for_the_chunks_a_teleport_starts() {
+        // Right after a teleport the game reports steady counts and nothing
+        // queued for over a second, before the integrated server has sent the
+        // first chunk: the quiet rule alone would call that loaded, and the
+        // scene would be measured over an empty view (#1749).
+        const LATE: usize = 30;
+        let (tx, rx) = mpsc::channel::<Request>();
+        let polls = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
+        let counted = std::sync::Arc::clone(&polls);
+        let server = thread::spawn(move || {
+            let mut seen = 0;
+            while let Ok(request) = rx.recv() {
+                if request.line == "status" {
+                    let chunks = if seen < LATE { 0 } else { 400 };
+                    seen += 1;
+                    counted.store(seen, std::sync::atomic::Ordering::SeqCst);
+                    let _ = request.reply.send(status(chunks));
+                } else {
+                    let _ = request.reply.send("{}".to_owned());
+                }
+            }
+        });
+        let control = Control(tx);
+        wait_loaded(&control, |_| true).expect("the scene loads");
+        assert!(
+            polls.load(std::sync::atomic::Ordering::SeqCst) > LATE,
+            "the load finished before the chunks arrived"
+        );
+        drop(control);
+        let _ = server.join();
+    }
 
     #[test]
     fn yaw_matches_vanilla() {
diff --git a/crates/horizon-client/src/bidi.rs b/crates/horizon-client/src/bidi.rs
new file mode 100644
index 000000000..c9c6caac7
--- /dev/null
+++ b/crates/horizon-client/src/bidi.rs
@@ -0,0 +1,302 @@
+//! Right-to-left text (`FormattedBidiReorder.reorder`, behind
+//! `Language.getVisualOrder`): the logical text a player types becomes the
+//! glyphs a font draws left to right. Arabic letters are shaped into their
+//! joined presentation forms (ICU's `ArabicShaping` with `LETTERS_SHAPE`), the
+//! text is reordered by the Unicode bidirectional algorithm, and characters in
+//! right-to-left runs are mirrored. Left-to-right text comes back unchanged.
+use crate::text::{Span, Text};
+use std::borrow::Cow;
+use unicode_bidi::{
+    BidiClass, Direction, Level, ParagraphBidiInfo, bidi_class, get_base_direction,
+};
+
+/// How a letter joins its neighbours, as ICU's shaper sees it: `Right` joins
+/// the letter before it only, `Dual` both neighbours, `Mark` is skipped over
+/// (diacritics) and `None` never joins.
+#[derive(Clone, Copy, PartialEq)]
+enum Join {
+    None,
+    Right,
+    Dual,
+    Mark,
+}
+use Join::{Dual, Mark, Right};
+
+/// ICU's joining table (`araLink`): code point ranges and their class, with the
+/// lam-alef ligatures at the end. Anything else is `Join::None`.
+const JOINS: &[(u32, u32, Join)] = &[
+    (0x0622, 0x0625, Right),
+    (0x0626, 0x0626, Dual),
+    (0x0627, 0x0627, Right),
+    (0x0628, 0x0628, Dual),
+    (0x0629, 0x0629, Right),
+    (0x062A, 0x062E, Dual),
+    (0x062F, 0x0632, Right),
+    (0x0633, 0x063A, Dual),
+    (0x0640, 0x0647, Dual),
+    (0x0648, 0x0649, Right),
+    (0x064A, 0x064A, Dual),
+    (0x064B, 0x0656, Mark),
+    (0x0670, 0x0670, Mark),
+    (0x0671, 0x0673, Right),
+    (0x0675, 0x0677, Right),
+    (0x0678, 0x0687, Dual),
+    (0x0688, 0x0699, Right),
+    (0x069A, 0x06B9, Dual),
+    (0x06BA, 0x06BA, Right),
+    (0x06BB, 0x06BF, Dual),
+    (0x06C0, 0x06C0, Right),
+    (0x06C1, 0x06C1, Dual),
+    (0x06C2, 0x06CB, Right),
+    (0x06CC, 0x06CC, Dual),
+    (0x06CD, 0x06CD, Right),
+    (0x06CE, 0x06D1, Dual),
+    (0x06D2, 0x06D3, Right),
+    (0x200D, 0x200D, Dual),
+    (0x206D, 0x206F, Mark),
+    (0xFEF5, 0xFEFC, Right),
+];
+
+/// Letters that have joined forms and the code point of the isolated one; the
+/// final, initial and medial forms follow it (a right-joining letter has the
+/// isolated and final only). The lam-alef ligatures are their own letters.
+/// ICU leaves the extended letters (پ چ ژ ک گ ی and the rest of U+0679 to
+/// U+06D3) unchanged, so they are in `JOINS` but not here.
+#[rustfmt::skip]
+const FORMS: &[(u32, u32)] = &[
+    (0x0622, 0xFE81), (0x0623, 0xFE83), (0x0624, 0xFE85), (0x0625, 0xFE87), (0x0626, 0xFE89),
+    (0x0627, 0xFE8D), (0x0628, 0xFE8F), (0x0629, 0xFE93), (0x062A, 0xFE95), (0x062B, 0xFE99),
+    (0x062C, 0xFE9D), (0x062D, 0xFEA1), (0x062E, 0xFEA5), (0x062F, 0xFEA9), (0x0630, 0xFEAB),
+    (0x0631, 0xFEAD), (0x0632, 0xFEAF), (0x0633, 0xFEB1), (0x0634, 0xFEB5), (0x0635, 0xFEB9),
+    (0x0636, 0xFEBD), (0x0637, 0xFEC1), (0x0638, 0xFEC5), (0x0639, 0xFEC9), (0x063A, 0xFECD),
+    (0x0641, 0xFED1), (0x0642, 0xFED5), (0x0643, 0xFED9), (0x0644, 0xFEDD), (0x0645, 0xFEE1),
+    (0x0646, 0xFEE5), (0x0647, 0xFEE9), (0x0648, 0xFEED), (0x0649, 0xFEEF), (0x064A, 0xFEF1),
+    (0xFEF5, 0xFEF5), (0xFEF7, 0xFEF7), (0xFEF9, 0xFEF9), (0xFEFB, 0xFEFB),
+];
+
+/// `Bidi_Mirroring_Glyph` (`UCharacter.getMirror`): each pair is two
+/// neighbouring characters that mirror each other.
+const MIRRORED: &str = "\
+        ()<>[]{}«»༺༻༼༽᚛᚜‹›⁅⁆⁽⁾₍₎∈∋∉∌∊∍∕⧵∟⯾∠⦣∡⦛∢⦠∤⫮∼∽≃⋍≅≌≒≓\
+        ≔≕≤≥≦≧≨≩≪≫≮≯≰≱≲≳≴≵≶≷≸≹≺≻≼≽≾≿⊀⊁⊂⊃⊄⊅⊆⊇⊈⊉⊊⊋⊏⊐⊑⊒⊘⦸⊢⊣⊦⫞\
+        ⊨⫤⊩⫣⊫⫥⊰⊱⊲⊳⊴⊵⊶⊷⊸⟜⋉⋊⋋⋌⋐⋑⋖⋗⋘⋙⋚⋛⋜⋝⋞⋟⋠⋡⋢⋣⋤⋥⋦⋧⋨⋩⋪⋫⋬⋭⋰⋱⋲⋺\
+        ⋳⋻⋴⋼⋶⋽⋷⋾⌈⌉⌊⌋〈〉❨❩❪❫❬❭❮❯❰❱❲❳❴❵⟃⟄⟅⟆⟈⟉⟋⟍⟕⟖⟝⟞⟢⟣⟤⟥⟦⟧⟨⟩⟪⟫\
+        ⟬⟭⟮⟯⦃⦄⦅⦆⦇⦈⦉⦊⦋⦌⦍⦐⦎⦏⦑⦒⦓⦔⦕⦖⦗⦘⦤⦥⦨⦩⦪⦫⦬⦭⦮⦯⧀⧁⧄⧅⧏⧐⧑⧒⧔⧕⧘⧙⧚⧛\
+        ⧨⧩⧸⧹⧼⧽⨫⨬⨭⨮⨴⨵⨼⨽⩤⩥⩹⩺⩻⩼⩽⩾⩿⪀⪁⪂⪃⪄⪅⪆⪇⪈⪉⪊⪋⪌⪍⪎⪏⪐⪑⪒⪓⪔⪕⪖⪗⪘⪙⪚\
+        ⪛⪜⪝⪞⪟⪠⪡⪢⪦⪧⪨⪩⪪⪫⪬⪭⪯⪰⪱⪲⪳⪴⪵⪶⪷⪸⪹⪺⪻⪼⪽⪾⪿⫀⫁⫂⫃⫄⫅⫆⫇⫈⫉⫊⫋⫌⫍⫎⫏⫐\
+        ⫑⫒⫓⫔⫕⫖⫬⫭⫷⫸⫹⫺⸂⸃⸄⸅⸉⸊⸌⸍⸜⸝⸠⸡⸢⸣⸤⸥⸦⸧⸨⸩⹕⹖⹗⹘⹙⹚⹛⹜〈〉《》「」『』【】\
+        〔〕〖〗〘〙〚〛﹙﹚﹛﹜﹝﹞﹤﹥（）＜＞［］｛｝｟｠｢｣";
+
+fn join(c: char) -> Join {
+    let c = c as u32;
+    JOINS
+        .iter()
+        .find(|&&(from, to, _)| (from..=to).contains(&c))
+        .map_or(Join::None, |&(_, _, join)| join)
+}
+
+/// The letter whose joined form `c` is (ICU shapes the forms again), or `c`.
+fn letter_of(c: char) -> char {
+    let c32 = c as u32;
+    if !matches!(c32, 0xFE70..=0xFEFC) {
+        return c;
+    }
+    if (0xFE70..0xFE80).contains(&c32) {
+        // The diacritics' forms pair up from fathatan on.
+        return char::from_u32(0x064B + (c32 - 0xFE70) / 2).unwrap_or(c);
+    }
+    FORMS
+        .iter()
+        .find(|&&(letter, iso)| {
+            let forms = if join(char::from_u32(letter).unwrap_or(c)) == Dual {
+                4
+            } else {
+                2
+            };
+            (iso..iso + forms).contains(&c32)
+        })
+        .and_then(|&(letter, _)| char::from_u32(letter))
+        .unwrap_or(c)
+}
+
+/// `ArabicShaping(LETTERS_SHAPE).shape`: lam followed by an alef (diacritics
+/// may sit between) becomes one ligature, then every letter takes the isolated,
+/// final, initial or medial form its neighbours call for. Diacritics take the
+/// tatweel form between two joined letters. The text can only get shorter.
+fn shape(text: &[char]) -> Vec<char> {
+    let letters: Vec<char> = text.iter().map(|&c| letter_of(c)).collect();
+    let mut chars = Vec::with_capacity(letters.len());
+    let mut i = 0;
+    while i < letters.len() {
+        if letters[i] == '\u{644}' {
+            let mut at = i + 1;
+            while letters.get(at).is_some_and(|&c| join(c) == Mark) {
+                at += 1;
+            }
+            let alef = letters.get(at).and_then(|&c| {
+                ['\u{622}', '\u{623}', '\u{625}', '\u{627}']
+                    .iter()
+                    .position(|&a| a == c)
+            });
+            if let Some(alef) = alef {
+                chars.push(char::from_u32(0xFEF5 + 2 * alef as u32).unwrap_or('\u{644}'));
+                chars.extend_from_slice(&letters[i + 1..at]);
+                i = at + 1;
+                continue;
+            }
+        }
+        chars.push(letters[i]);
+        i += 1;
+    }
+    // Whether the nearest letter before joins the next one, and the joins of
+    // the nearest letter after.
+    let mut joins_next = false;
+    let mut out = Vec::with_capacity(chars.len());
+    for (i, &c) in chars.iter().enumerate() {
+        let next_joins = chars[i + 1..]
+            .iter()
+            .map(|&n| join(n))
+            .find(|&j| j != Mark)
+            .is_some_and(|j| j != Join::None);
+        let kind = join(c);
+        let shaped = match kind {
+            Join::None => {
+                joins_next = false;
+                c
+            }
+            Mark => match c as u32 {
+                m @ 0x064B..=0x0652 => {
+                    let iso = 0xFE70 + 2 * (m - 0x064B);
+                    let tatweel = joins_next && next_joins && !matches!(m, 0x064C | 0x064D);
+                    char::from_u32(iso + u32::from(tatweel)).unwrap_or(c)
+                }
+                _ => c,
+            },
+            Right | Dual => {
+                let to_next = kind == Dual && next_joins;
+                let form = match (joins_next, to_next) {
+                    (false, false) => 0,
+                    (true, false) => 1,
+                    (false, true) => 2,
+                    (true, true) => 3,
+                };
+                joins_next = kind == Dual;
+                FORMS
+                    .binary_search_by_key(&(c as u32), |&(letter, _)| letter)
+                    .ok()
+                    .and_then(|at| char::from_u32(FORMS[at].1 + form))
+                    .unwrap_or(c)
+            }
+        };
+        out.push(shaped);
+    }
+    out
+}
+
+/// `UCharacter.getMirror`.
+fn mirror(c: char) -> char {
+    if bidi_class(c) != BidiClass::ON {
+        return c;
+    }
+    let mut pairs = MIRRORED.chars();
+    while let (Some(a), Some(b)) = (pairs.next(), pairs.next()) {
+        if c == a {
+            return b;
+        }
+        if c == b {
+            return a;
+        }
+    }
+    c
+}
+
+/// Whether a character can change anything: right-to-left letters and numbers,
+/// the explicit direction controls and the diacritics that shaping turns into
+/// letters. Without any, left-to-right text keeps its order.
+fn directional(c: char) -> bool {
+    c as u32 >= 0x0590
+        && (matches!(c as u32, 0x064B..=0x0652)
+            || matches!(
+                bidi_class(c),
+                BidiClass::R
+                    | BidiClass::AL
+                    | BidiClass::AN
+                    | BidiClass::LRE
+                    | BidiClass::RLE
+                    | BidiClass::LRO
+                    | BidiClass::RLO
+                    | BidiClass::PDF
+                    | BidiClass::LRI
+                    | BidiClass::RLI
+                    | BidiClass::FSI
+                    | BidiClass::PDI
+            ))
+}
+
+/// Whether `chars` keep their order and shapes: left-to-right text without
+/// anything directional, in a language that reads left to right by default.
+fn unchanged(mut chars: impl Iterator<Item = char>, default_rtl: bool) -> bool {
+    !default_rtl && !chars.any(directional)
+}
+
+/// `FormattedBidiReorder.reorder`: `chars` shaped, in visual order, with each
+/// character's position in the shaped text. A character's style is the one at
+/// its position in the shaped text, as `SubStringSource` takes it (the text
+/// shrinks at a lam-alef ligature).
+fn reorder(chars: &[char], default_rtl: bool) -> Vec<(char, usize)> {
+    let shaped = shape(chars);
+    let plain: String = shaped.iter().collect();
+    // DEFAULT_RTL only changes text without a strong character.
+    let level =
+        (default_rtl && get_base_direction(plain.as_str()) == Direction::Mixed).then(Level::rtl);
+    let info = ParagraphBidiInfo::new(&plain, level);
+    let levels = info.reordered_levels_per_char(0..plain.len());
+    ParagraphBidiInfo::reorder_visual(&levels)
+        .into_iter()
+        .map(|i| {
+            let c = if levels[i].is_rtl() {
+                mirror(shaped[i])
+            } else {
+                shaped[i]
+            };
+            (c, i)
+        })
+        .collect()
+}
+
+/// `Language.getVisualOrder` of a text (its `§` codes already resolved), for
+/// the current language's direction.
+pub fn visual(text: &Text) -> Cow<'_, Text> {
+    let default_rtl = crate::lang::bidirectional();
+    if unchanged(text.chars().map(|(c, _)| c), default_rtl) {
+        return Cow::Borrowed(text);
+    }
+    let chars: Vec<char> = text.chars().map(|(c, _)| c).collect();
+    let styles: Vec<_> = text.chars().map(|(_, style)| style).collect();
+    let mut out = Text::default();
+    for (c, at) in reorder(&chars, default_rtl) {
+        match out.spans.last_mut() {
+            Some(span) if span.style == *styles[at] => span.text.push(c),
+            _ => out.spans.push(Span {
+                text: c.to_string(),
+                style: styles[at].clone(),
+            }),
+        }
+    }
+    Cow::Owned(out)
+}
+
+/// The same for a plain string.
+pub fn visual_str(s: &str) -> Cow<'_, str> {
+    let default_rtl = crate::lang::bidirectional();
+    if unchanged(s.chars(), default_rtl) {
+        return Cow::Borrowed(s);
+    }
+    let chars: Vec<char> = s.chars().collect();
+    Cow::Owned(
+        reorder(&chars, default_rtl)
+            .into_iter()
+            .map(|(c, _)| c)
+            .collect(),
+    )
+}
diff --git a/crates/horizon-client/src/biome.rs b/crates/horizon-client/src/biome.rs
index c8c15e44e..46c1e16ca 100644
--- a/crates/horizon-client/src/biome.rs
+++ b/crates/horizon-client/src/biome.rs
@@ -1,7 +1,7 @@
 //! Biome colours from the pinned biome definitions and colormaps
 //! (`Biome.getGrassColor`/`getFoliageColor`/..., `BlockTintSources`).
 use crate::Result;
-use horizon_core::{noise::SimplexNoise, random::LegacyRandom};
+use horizon_core::{noise::SimplexNoise, position::BlockPos, random::LegacyRandom};
 use serde_json::Value;
 use std::{collections::HashMap, fs, path::Path};
 
@@ -33,6 +33,8 @@ pub struct BiomeInfo {
     pub increased_fire_burnout: bool,
     pub name: String,
     pub temperature: f32,
+    /// `temperature_modifier: frozen` (the frozen oceans).
+    pub frozen: bool,
     pub downfall: f32,
     pub precipitation: bool,
     pub grass: u32,
@@ -45,6 +47,26 @@ pub struct BiomeInfo {
     pub fog: Option<u32>,
     pub water_fog: u32,
 }
+impl BiomeInfo {
+    /// `Biome.getHeightAdjustedTemperature`: the frozen modifier, then cooler
+    /// with height above `sea_level + 17`.
+    pub fn temperature_at(&self, pos: BlockPos, sea_level: i32) -> f32 {
+        use horizon_world::worldgen::biome_temperature::{
+            BiomeTemperatureSettings, TemperatureModifier,
+        };
+        BiomeTemperatureSettings {
+            base_temperature: self.temperature,
+            modifier: if self.frozen {
+                TemperatureModifier::Frozen
+            } else {
+                TemperatureModifier::None
+            },
+            has_precipitation: self.precipitation,
+            downfall: self.downfall,
+        }
+        .height_adjusted(pos, sea_level)
+    }
+}
 pub struct Biomes {
     pub list: Vec<BiomeInfo>,
     pub index: HashMap<String, u16>,
@@ -135,6 +157,7 @@ impl Biomes {
                     .as_bool()
                     .unwrap_or(false),
                 temperature,
+                frozen: v["temperature_modifier"].as_str() == Some("frozen"),
                 downfall,
                 precipitation: v["has_precipitation"].as_bool().unwrap_or(true),
                 grass: color(&effects["grass_color"])
diff --git a/crates/horizon-client/src/block_entity_anim.rs b/crates/horizon-client/src/block_entity_anim.rs
index d91748e73..fd91051fa 100644
--- a/crates/horizon-client/src/block_entity_anim.rs
+++ b/crates/horizon-client/src/block_entity_anim.rs
@@ -648,6 +648,61 @@ impl Conduit {
     }
 }
 
+/// What `ConduitBlockEntity.serverTick`'s 40-tick check decided.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct ConduitCheck {
+    /// The shape changed: `CONDUIT_ACTIVATE` (true) or `CONDUIT_DEACTIVATE`.
+    pub toggled: Option<bool>,
+    /// The frame blocks counted, while the conduit is active: `applyEffects`
+    /// and `updateAndAttackTarget` follow (the attack needs 42 or more).
+    pub frames: Option<usize>,
+}
+
+/// `ConduitBlockEntity` (server side): what `serverTick` keeps between ticks.
+#[derive(Clone, Debug, Default)]
+pub struct ConduitServer {
+    shape: Conduit,
+    /// `destroyTarget`: the mob id of the enemy being struck.
+    pub target: Option<u32>,
+    next_ambient_sound: i64,
+}
+
+impl ConduitServer {
+    /// The `gameTime % 40` part of `serverTick`: the shape is checked again.
+    pub fn check(
+        &mut self,
+        pos: [i32; 3],
+        game_time: i64,
+        is_water: impl Fn([i32; 3]) -> bool,
+        is_frame: impl Fn([i32; 3]) -> bool,
+    ) -> Option<ConduitCheck> {
+        if game_time % 40 != 0 {
+            return None;
+        }
+        let active = self.shape.update_shape(pos, &is_water, &is_frame);
+        let toggled = (active != self.shape.is_active).then_some(active);
+        self.shape.is_active = active;
+        Some(ConduitCheck {
+            toggled,
+            frames: active.then_some(self.shape.effect_blocks.len()),
+        })
+    }
+    /// The sounds of an active conduit at the end of `serverTick`: whether
+    /// `CONDUIT_AMBIENT` (every 80 ticks) and `CONDUIT_AMBIENT_SHORT` (every
+    /// 60 to 99 ticks) play.
+    pub fn ambient(&mut self, game_time: i64, random: &mut impl RandomSource) -> (bool, bool) {
+        if !self.shape.is_active {
+            return (false, false);
+        }
+        let short = game_time > self.next_ambient_sound;
+        if short {
+            self.next_ambient_sound =
+                game_time + 60 + i64::from(random.next_int_bound(40).unwrap_or(0));
+        }
+        (game_time % 80 == 0, short)
+    }
+}
+
 /// `SkullBlockEntity` animation (client ticker of dragon and piglin heads).
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub struct Skull {
@@ -832,6 +887,8 @@ pub struct BlockEntityAnims {
     pub gateways: FxHashMap<[i32; 3], EndGateway>,
     /// The integrated server's copies of the gateways (`portalTick`).
     pub gateway_servers: FxHashMap<[i32; 3], EndGateway>,
+    /// The integrated server's copies of the conduits (`serverTick`).
+    pub conduit_servers: FxHashMap<[i32; 3], ConduitServer>,
     /// The client level's random (conduit particles).
     pub random: LegacyRandom,
     /// [`Ticker`] by block state id (see [`BlockEntityAnims::classify`]).
@@ -854,6 +911,7 @@ impl Default for BlockEntityAnims {
             pots: FxHashMap::default(),
             gateways: FxHashMap::default(),
             gateway_servers: FxHashMap::default(),
+            conduit_servers: FxHashMap::default(),
             random: LegacyRandom::new(0x6c6576656c),
             kinds: Vec::new(),
             present: Vec::new(),
@@ -909,6 +967,7 @@ impl BlockEntityAnims {
         self.pots.retain(|p, _| keep(*p));
         self.gateways.retain(|p, _| keep(*p));
         self.gateway_servers.retain(|p, _| keep(*p));
+        self.conduit_servers.retain(|p, _| keep(*p));
     }
     /// `getOpenNess(partial)` of the chest or ender chest at `pos`.
     pub fn lid(&self, pos: [i32; 3], partial: f32) -> f32 {
diff --git a/crates/horizon-client/src/block_entity_render.rs b/crates/horizon-client/src/block_entity_render.rs
index 28a876d80..514326e66 100644
--- a/crates/horizon-client/src/block_entity_render.rs
+++ b/crates/horizon-client/src/block_entity_render.rs
@@ -149,6 +149,8 @@ pub fn draw_part(
                 layer: 0,
                 color,
                 light,
+
+                glint_uv: [0.0, 0.0],
             });
         }
     }
@@ -610,7 +612,9 @@ fn sign_text_calls(
         .iter()
         .enumerate()
         .map(|(i, line)| {
+            // The line that fits, in the order it is drawn (getVisualOrder).
             let shown = first_line(line, data.max_line_width(), &advance);
+            let shown = crate::bidi::visual_str(&shown).into_owned();
             TextCall {
                 matrix: m,
                 x: -((width(&shown) as i32) / 2) as f32,
@@ -648,6 +652,8 @@ fn draw_text(scene: &Scene, call: &TextCall, out: &mut Vec<Vertex>) {
                         layer: 0,
                         color: c,
                         light: call.light,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
@@ -734,7 +740,7 @@ pub struct Scene<'a> {
     /// The skin sprite a `player_head` shows at a position (`SkullBlockRenderer`
     /// profile → skin): a downloaded `skins/<sha1>` slot or the profile's
     /// `DefaultPlayerSkin` fallback; None keeps `SKIN_BY_TYPE` (`DefaultPlayerSkin.getDefaultTexture`, slim steve).
-    pub skull: &'a dyn Fn([i32; 3]) -> Option<&'a str>,
+    pub skull: &'a dyn Fn([i32; 3]) -> Option<String>,
     /// Font glyph cell (none for blank glyphs such as the space) and advance.
     pub glyph: &'a dyn Fn(char) -> (Option<Rect>, f32),
 }
@@ -1286,11 +1292,12 @@ impl BlockEntityRenderer {
                 };
                 // SkullBlockRenderer.getRenderType: the profile's skin when it
                 // resolves, `SKIN_BY_TYPE` (steve) otherwise.
-                let texture = if *kind == SkullType::Player {
-                    (scene.skull)(pos).unwrap_or(texture)
+                let skin = if *kind == SkullType::Player {
+                    (scene.skull)(pos)
                 } else {
-                    texture
+                    None
                 };
+                let texture = skin.as_deref().unwrap_or(texture);
                 let (Some(model), Some(paint)) =
                     (self.models.get(model), paint(texture, 0xFFFFFF, packed))
                 else {
@@ -1714,6 +1721,8 @@ impl BeamPart {
                     layer: 6,
                     color,
                     light: self.wrap,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
@@ -1784,6 +1793,7 @@ fn portal_cube(m: Mat4, faces: &[Direction], layer: u32, out: &mut Vec<Vertex>)
                 layer,
                 color: 0,
                 light: 0,
+                glint_uv: [0.0, 0.0],
             });
         }
     }
diff --git a/crates/horizon-client/src/blocks.rs b/crates/horizon-client/src/blocks.rs
index 27a36396a..8e906e1bc 100644
--- a/crates/horizon-client/src/blocks.rs
+++ b/crates/horizon-client/src/blocks.rs
@@ -90,7 +90,7 @@ pub const MAP_COLORS: [u32; 62] = [
     14200723, 8365974,
 ];
 /// The 12 edges of the unit cube (outline data predating the export).
-fn cube_edges() -> Vec<[f64; 6]> {
+pub fn cube_edges() -> Vec<[f64; 6]> {
     let mut edges = Vec::new();
     for a in 0..3 {
         for (u, v) in [(0., 0.), (1., 0.), (0., 1.), (1., 1.)] {
diff --git a/crates/horizon-client/src/breaking.rs b/crates/horizon-client/src/breaking.rs
index 84eedae75..df6d0f33b 100644
--- a/crates/horizon-client/src/breaking.rs
+++ b/crates/horizon-client/src/breaking.rs
@@ -49,6 +49,8 @@ pub fn geometry(
                     color: 0xffff_ffff,
                     light: stage_light(stage),
                     normal: [0; 4],
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
diff --git a/crates/horizon-client/src/brewing.rs b/crates/horizon-client/src/brewing.rs
index f29bfc08b..b3cda5f90 100644
--- a/crates/horizon-client/src/brewing.rs
+++ b/crates/horizon-client/src/brewing.rs
@@ -9,232 +9,10 @@ use crate::{
 use serde_json::Value;
 use std::{collections::HashSet, fs, path::Path, sync::Arc};
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Category {
-    Beneficial,
-    Harmful,
-    Neutral,
-}
-/// A `MobEffect`: id (without namespace), colour, category, instantaneous.
-#[derive(Clone, Copy, Debug)]
-pub struct EffectDef {
-    pub id: &'static str,
-    pub color: u32,
-    pub category: Category,
-    pub instant: bool,
-}
-const fn fx(id: &'static str, color: u32, category: Category) -> EffectDef {
-    EffectDef {
-        id,
-        color,
-        category,
-        instant: false,
-    }
-}
-use Category::{Beneficial as B, Harmful as H, Neutral as N};
-/// `MobEffects` in registration order.
-pub const EFFECTS: &[EffectDef] = &[
-    fx("speed", 3402751, B),
-    fx("slowness", 9154528, H),
-    fx("haste", 14270531, B),
-    fx("mining_fatigue", 4866583, H),
-    fx("strength", 16762624, B),
-    EffectDef {
-        id: "instant_health",
-        color: 16262179,
-        category: B,
-        instant: true,
-    },
-    EffectDef {
-        id: "instant_damage",
-        color: 11101546,
-        category: H,
-        instant: true,
-    },
-    fx("jump_boost", 16646020, B),
-    fx("nausea", 5578058, H),
-    fx("regeneration", 13458603, B),
-    fx("resistance", 9520880, B),
-    fx("fire_resistance", 16750848, B),
-    fx("water_breathing", 10017472, B),
-    fx("invisibility", 16185078, B),
-    fx("blindness", 2039587, H),
-    fx("night_vision", 12779366, B),
-    fx("hunger", 5797459, H),
-    fx("weakness", 4738376, H),
-    fx("poison", 8889187, H),
-    fx("wither", 7561558, H),
-    fx("health_boost", 16284963, B),
-    fx("absorption", 2445989, B),
-    EffectDef {
-        id: "saturation",
-        color: 16262179,
-        category: B,
-        instant: true,
-    },
-    fx("glowing", 9740385, N),
-    fx("levitation", 13565951, H),
-    fx("luck", 5882118, B),
-    fx("unluck", 12624973, H),
-    fx("slow_falling", 15978425, B),
-    fx("conduit_power", 1950417, B),
-    fx("dolphins_grace", 8954814, B),
-    fx("bad_omen", 745784, N),
-    fx("hero_of_the_village", 4521796, B),
-    fx("darkness", 2696993, H),
-    fx("trial_omen", 1484454, N),
-    fx("raid_omen", 14565464, N),
-    fx("wind_charged", 12438015, H),
-    fx("weaving", 7891290, H),
-    fx("oozing", 10092451, H),
-    fx("infested", 9214860, H),
-    fx("breath_of_the_nautilus", 65518, B),
-];
-pub fn effect(id: &str) -> Option<&'static EffectDef> {
-    let id = id.trim_start_matches("minecraft:");
-    EFFECTS.iter().find(|e| e.id == id)
-}
-/// A `Potion`: id, name suffix (`item.minecraft.potion.effect.<name>`) and
-/// effects as (effect, duration ticks, amplifier).
-#[derive(Clone, Copy, Debug)]
-pub struct PotionDef {
-    pub id: &'static str,
-    pub name: &'static str,
-    pub effects: &'static [(&'static str, i32, i32)],
-}
-const fn p(
-    id: &'static str,
-    name: &'static str,
-    effects: &'static [(&'static str, i32, i32)],
-) -> PotionDef {
-    PotionDef { id, name, effects }
-}
-/// `Potions` in registration order.
-pub const POTIONS: &[PotionDef] = &[
-    p("water", "water", &[]),
-    p("mundane", "mundane", &[]),
-    p("thick", "thick", &[]),
-    p("awkward", "awkward", &[]),
-    p("night_vision", "night_vision", &[("night_vision", 3600, 0)]),
-    p(
-        "long_night_vision",
-        "night_vision",
-        &[("night_vision", 9600, 0)],
-    ),
-    p("invisibility", "invisibility", &[("invisibility", 3600, 0)]),
-    p(
-        "long_invisibility",
-        "invisibility",
-        &[("invisibility", 9600, 0)],
-    ),
-    p("leaping", "leaping", &[("jump_boost", 3600, 0)]),
-    p("long_leaping", "leaping", &[("jump_boost", 9600, 0)]),
-    p("strong_leaping", "leaping", &[("jump_boost", 1800, 1)]),
-    p(
-        "fire_resistance",
-        "fire_resistance",
-        &[("fire_resistance", 3600, 0)],
-    ),
-    p(
-        "long_fire_resistance",
-        "fire_resistance",
-        &[("fire_resistance", 9600, 0)],
-    ),
-    p("swiftness", "swiftness", &[("speed", 3600, 0)]),
-    p("long_swiftness", "swiftness", &[("speed", 9600, 0)]),
-    p("strong_swiftness", "swiftness", &[("speed", 1800, 1)]),
-    p("slowness", "slowness", &[("slowness", 1800, 0)]),
-    p("long_slowness", "slowness", &[("slowness", 4800, 0)]),
-    p("strong_slowness", "slowness", &[("slowness", 400, 3)]),
-    p(
-        "turtle_master",
-        "turtle_master",
-        &[("slowness", 400, 3), ("resistance", 400, 2)],
-    ),
-    p(
-        "long_turtle_master",
-        "turtle_master",
-        &[("slowness", 800, 3), ("resistance", 800, 2)],
-    ),
-    p(
-        "strong_turtle_master",
-        "turtle_master",
-        &[("slowness", 400, 5), ("resistance", 400, 3)],
-    ),
-    p(
-        "water_breathing",
-        "water_breathing",
-        &[("water_breathing", 3600, 0)],
-    ),
-    p(
-        "long_water_breathing",
-        "water_breathing",
-        &[("water_breathing", 9600, 0)],
-    ),
-    p("healing", "healing", &[("instant_health", 1, 0)]),
-    p("strong_healing", "healing", &[("instant_health", 1, 1)]),
-    p("harming", "harming", &[("instant_damage", 1, 0)]),
-    p("strong_harming", "harming", &[("instant_damage", 1, 1)]),
-    p("poison", "poison", &[("poison", 900, 0)]),
-    p("long_poison", "poison", &[("poison", 1800, 0)]),
-    p("strong_poison", "poison", &[("poison", 432, 1)]),
-    p("regeneration", "regeneration", &[("regeneration", 900, 0)]),
-    p(
-        "long_regeneration",
-        "regeneration",
-        &[("regeneration", 1800, 0)],
-    ),
-    p(
-        "strong_regeneration",
-        "regeneration",
-        &[("regeneration", 450, 1)],
-    ),
-    p("strength", "strength", &[("strength", 3600, 0)]),
-    p("long_strength", "strength", &[("strength", 9600, 0)]),
-    p("strong_strength", "strength", &[("strength", 1800, 1)]),
-    p("weakness", "weakness", &[("weakness", 1800, 0)]),
-    p("long_weakness", "weakness", &[("weakness", 4800, 0)]),
-    p("luck", "luck", &[("luck", 6000, 0)]),
-    p("slow_falling", "slow_falling", &[("slow_falling", 1800, 0)]),
-    p(
-        "long_slow_falling",
-        "slow_falling",
-        &[("slow_falling", 4800, 0)],
-    ),
-    p("wind_charged", "wind_charged", &[("wind_charged", 3600, 0)]),
-    p("weaving", "weaving", &[("weaving", 3600, 0)]),
-    p("oozing", "oozing", &[("oozing", 3600, 0)]),
-    p("infested", "infested", &[("infested", 3600, 0)]),
-];
-pub fn potion(id: &str) -> Option<&'static PotionDef> {
-    let id = id.trim_start_matches("minecraft:");
-    POTIONS.iter().find(|p| p.id == id)
-}
-/// `PotionContents.BASE_POTION_COLOR` (ARGB -13083194) as RGB.
-pub const BASE_POTION_COLOR: u32 = 0x385DC6;
-/// `PotionContents.getColor`: amplifier-weighted mix of visible effect colours.
-pub fn potion_color(id: Option<&str>) -> u32 {
-    let Some(def) = id.and_then(potion) else {
-        return BASE_POTION_COLOR;
-    };
-    let (mut r, mut g, mut b, mut total) = (0u32, 0u32, 0u32, 0u32);
-    for (e, _, amp) in def.effects {
-        let Some(e) = effect(e) else { continue };
-        let w = *amp as u32 + 1;
-        r += w * (e.color >> 16 & 255);
-        g += w * (e.color >> 8 & 255);
-        b += w * (e.color & 255);
-        total += w;
-    }
-    match (
-        r.checked_div(total),
-        g.checked_div(total),
-        b.checked_div(total),
-    ) {
-        (Some(r), Some(g), Some(b)) => (r << 16) | (g << 8) | b,
-        _ => BASE_POTION_COLOR,
-    }
-}
+pub use horizon_client_core::potions::{
+    BASE_POTION_COLOR, Category, EFFECTS, EffectDef, POTIONS, PotionDef, effect, namespaced,
+    potion, potion_color,
+};
 /// `MobEffectUtil.formatDuration` at 20 TPS: m:ss or h:mm:ss.
 pub fn format_duration(ticks: i32) -> String {
     let secs = ticks / 20;
diff --git a/crates/horizon-client/src/bundle.rs b/crates/horizon-client/src/bundle.rs
index 42473729f..948e2f4a9 100644
--- a/crates/horizon-client/src/bundle.rs
+++ b/crates/horizon-client/src/bundle.rs
@@ -1,6 +1,7 @@
 //! `BundleContents.Mutable`: what a bundle takes in and gives back, by
 //! weight. The menus (`menu`, `lan::menu`) run `BundleItem`'s click
 //! overrides on it.
+use crate::item_data::BundleSelected;
 use crate::items::{ItemStack, Items};
 use horizon_world::nbt::Tag;
 
@@ -97,6 +98,8 @@ pub fn can_be_in_bundle(stack: &ItemStack) -> bool {
 pub struct Contents {
     items: Vec<ItemStack>,
     weight: Weight,
+    /// `selectedItem`: an index into `items`, -1 for none.
+    selected: i32,
 }
 
 impl Contents {
@@ -104,9 +107,11 @@ impl Contents {
     pub fn of(items: &Items, stack: &ItemStack) -> Option<Self> {
         let inside = contents_of(items, stack)?.to_vec();
         let weight = contents_weight(items, &inside);
+        let selected = stack.data().map_or(-1, |d| d.bundle_selected.0);
         Some(Self {
             items: inside,
             weight,
+            selected,
         })
     }
 
@@ -154,18 +159,26 @@ impl Contents {
         amount
     }
 
-    /// `removeOne`: the first stack (Horizon keeps no selected item).
+    /// `removeOne`: the selected stack, else the first; nothing is selected after.
     pub fn remove_one(&mut self, items: &Items) -> Option<ItemStack> {
         if self.items.is_empty() {
             return None;
         }
-        let stack = self.items.remove(0);
+        let at =
+            usize::try_from(self.selected).map_or(0, |i| if i < self.items.len() { i } else { 0 });
+        let stack = self.items.remove(at);
         self.weight = self
             .weight
             .sub(item_weight(items, &stack).times(stack.count));
+        self.selected = -1;
         Some(stack)
     }
 
+    /// `getSelectedItemIndex`.
+    pub fn selected(&self) -> i32 {
+        self.selected
+    }
+
     /// The stacks inside, in display order (the first is the next out).
     pub fn items(&self) -> &[ItemStack] {
         &self.items
@@ -200,11 +213,28 @@ impl Contents {
 
     /// `toImmutable`, written back into the bundle's component.
     pub fn store(self, bundle: &mut ItemStack) {
-        bundle.data_mut().bundle_contents = self.items;
+        let data = bundle.data_mut();
+        data.bundle_contents = self.items;
+        data.bundle_selected = BundleSelected(self.selected);
         bundle.tidy();
     }
 }
 
+/// `BundleItem.toggleSelectedItem`: select `index`, or nothing when it is the
+/// selected one already or outside the contents.
+pub fn toggle_selected(bundle: &mut ItemStack, index: i32) {
+    let Some(data) = bundle.extra.as_deref_mut() else {
+        return;
+    };
+    let inside = (0..data.bundle_contents.len() as i32).contains(&index);
+    let selected = if data.bundle_selected.0 != index && inside {
+        index
+    } else {
+        -1
+    };
+    data.bundle_selected = BundleSelected(selected);
+}
+
 #[cfg(test)]
 mod tests {
     use super::Weight;
@@ -232,8 +262,10 @@ pub struct TooltipLayout {
     /// The component's own width (96) and height, the text's excluded.
     pub width: f32,
     pub height: f32,
-    /// Each slot's top-left and the stack in it, in reading order.
+    /// Each slot's top-left and the stack in it, in drawing order.
     pub slots: Vec<([f32; 2], ItemStack)>,
+    /// The position in `slots` of the selected item, which is drawn highlighted.
+    pub selected: Option<usize>,
     /// The `+N` of the items past the grid: its top-left and the count.
     pub overflow: Option<([f32; 2], u32)>,
     /// The progress bar's top-left, its fill's width out of 94, and whether
@@ -266,6 +298,7 @@ pub fn tooltip_layout(
             width: 96.0,
             height: description_height + 13.0 + 8.0,
             slots: Vec::new(),
+            selected: None,
             overflow: None,
             bar: [x + offset, y + description_height + 4.0],
             fill: 0.0,
@@ -282,6 +315,7 @@ pub fn tooltip_layout(
     let x_start = x + offset + 96.0;
     let y_start = y + grid_height;
     let mut slots = Vec::with_capacity(shown.len());
+    let mut selected = None;
     let mut overflow = None;
     // Rows fill bottom-up and columns right-to-left, as vanilla draws them.
     let mut slot = 0;
@@ -290,8 +324,13 @@ pub fn tooltip_layout(
             let at = [x_start - column as f32 * 24.0, y_start - row as f32 * 24.0];
             if hidden > 0 && row == 1 && column == 1 {
                 overflow = Some((at, hidden));
-            } else if let Some(stack) = shown.get(slot) {
-                slots.push((at, stack.clone()));
+            } else if slot < shown.len() {
+                // `extractSlot`: the cell of slot number n holds item `size - n`.
+                let index = shown.len() - 1 - slot;
+                if usize::try_from(contents.selected()) == Ok(index) {
+                    selected = Some(slots.len());
+                }
+                slots.push((at, shown[index].clone()));
                 slot += 1;
             }
         }
@@ -301,6 +340,7 @@ pub fn tooltip_layout(
         width: 96.0,
         height: grid_height + 13.0 + 8.0,
         slots,
+        selected,
         overflow,
         bar: [x + offset, y + grid_height + 4.0],
         // `Mth.mulAndTruncate(weight, 94)`, kept within the bar.
@@ -349,8 +389,8 @@ mod tooltip_tests {
         assert_eq!(layout.slots.len(), 12);
         assert_eq!(layout.overflow, None);
         assert_eq!(layout.height, 3.0 * 24.0 + 13.0 + 8.0);
-        // Rows fill bottom-up and columns right-to-left: the first item is in
-        // the bottom-right cell, the twelfth in the top-left.
+        // Rows fill bottom-up and columns right-to-left: the twelfth item is in
+        // the bottom-right cell, the first in the top-left.
         assert_eq!(layout.slots[0].0, [96.0 - 24.0, 3.0 * 24.0 - 24.0]);
         assert_eq!(&*layout.slots[0].1.item, "minecraft:stone");
         assert_eq!(layout.slots[11].0, [0.0, 0.0]);
diff --git a/crates/horizon-client/src/cauldron.rs b/crates/horizon-client/src/cauldron.rs
index 03fb0676d..25a709e26 100644
--- a/crates/horizon-client/src/cauldron.rs
+++ b/crates/horizon-client/src/cauldron.rs
@@ -40,6 +40,8 @@ pub struct Interaction {
     /// The cauldron's new state.
     pub block: Option<BlockState>,
     pub sound: Option<&'static str>,
+    /// The custom statistic the player earns (`use_cauldron`, ...).
+    pub stat: Option<&'static str>,
 }
 
 fn state(name: &str, level: Option<u8>) -> BlockState {
@@ -57,6 +59,7 @@ fn pass() -> Interaction {
         outcome: Outcome::Pass,
         block: None,
         sound: None,
+        stat: None,
     }
 }
 
@@ -117,11 +120,12 @@ fn lowered(cauldron: &BlockState) -> BlockState {
     }
 }
 
-fn changed(block: BlockState, sound: Option<&'static str>) -> Interaction {
+fn changed(block: BlockState, sound: Option<&'static str>, stat: &'static str) -> Interaction {
     Interaction {
         outcome: Outcome::Success,
         block: Some(block),
         sound,
+        stat: Some(stat),
     }
 }
 
@@ -179,18 +183,22 @@ pub fn interact(
             stack.data_mut().dyed_color = None;
             stack.tidy();
         }
-        return changed(lowered(cauldron), None);
+        return changed(lowered(cauldron), None, "clean_armor");
     }
     let fill_bucket = |player: &mut dyn Player, new: &str, can_fill: bool, sound| {
         if !can_fill {
             return pass();
         }
         filled(player, ItemStack::new(new, 1), true);
-        changed(state("minecraft:cauldron", None), Some(sound))
+        changed(
+            state("minecraft:cauldron", None),
+            Some(sound),
+            "use_cauldron",
+        )
     };
     let empty_bucket = |player: &mut dyn Player, block: BlockState, sound| {
         filled(player, ItemStack::new("minecraft:bucket", 1), true);
-        changed(block, Some(sound))
+        changed(block, Some(sound), "fill_cauldron")
     };
     match item {
         "minecraft:lava_bucket" => {
@@ -199,6 +207,7 @@ pub fn interact(
                     outcome: Outcome::Consume,
                     block: None,
                     sound: None,
+                    stat: None,
                 }
             } else {
                 empty_bucket(
@@ -221,6 +230,7 @@ pub fn interact(
                     outcome: Outcome::Consume,
                     block: None,
                     sound: None,
+                    stat: None,
                 }
             } else {
                 empty_bucket(
@@ -241,6 +251,7 @@ pub fn interact(
             changed(
                 state("minecraft:water_cauldron", Some(1)),
                 Some("minecraft:item.bottle.empty"),
+                "use_cauldron",
             )
         }
         ("water", "minecraft:bucket") => fill_bucket(
@@ -255,7 +266,11 @@ pub fn interact(
                 ItemStack::new("minecraft:potion", 1).with_potion("minecraft:water"),
                 true,
             );
-            changed(lowered(cauldron), Some("minecraft:item.bottle.fill"))
+            changed(
+                lowered(cauldron),
+                Some("minecraft:item.bottle.fill"),
+                "use_cauldron",
+            )
         }
         ("water", "minecraft:potion") => {
             if level == 3 || !water_potion {
@@ -266,7 +281,7 @@ pub fn interact(
             // BlockState.cycle on a 1..=3 property
             next.properties
                 .insert("level".into(), (level % 3 + 1).to_string());
-            changed(next, Some("minecraft:item.bottle.empty"))
+            changed(next, Some("minecraft:item.bottle.empty"), "use_cauldron")
         }
         ("water", name)
             if name
@@ -283,7 +298,7 @@ pub fn interact(
             cleaned.data_mut().banner_patterns.pop();
             cleaned.tidy();
             filled(player, cleaned, false);
-            changed(lowered(cauldron), None)
+            changed(lowered(cauldron), None, "clean_banner")
         }
         ("water", name)
             if name
@@ -292,7 +307,7 @@ pub fn interact(
                 .is_some_and(|c| COLORS.contains(&c)) =>
         {
             filled(player, held.transmute("minecraft:shulker_box", 1), false);
-            changed(lowered(cauldron), None)
+            changed(lowered(cauldron), None, "clean_shulker_box")
         }
         ("lava", "minecraft:bucket") => fill_bucket(
             player,
diff --git a/crates/horizon-client/src/chunk.rs b/crates/horizon-client/src/chunk.rs
index 7cd375343..b0dd377c7 100644
--- a/crates/horizon-client/src/chunk.rs
+++ b/crates/horizon-client/src/chunk.rs
@@ -2,6 +2,7 @@
 //! threads can mesh and light immutable snapshots while the game thread edits
 //! (copy-on-write through `Arc::make_mut`).
 use horizon_core::paletted::{PalettedContainer, Strategy};
+use horizon_world::nbt::{Compound, Tag};
 use horizon_world::registry::BlockStateId;
 use std::sync::{Arc, OnceLock};
 
@@ -155,7 +156,7 @@ pub struct Chunk {
     /// positions, applied once by LevelChunk.postProcessGeneration.
     pub postprocess: Vec<[i32; 3]>,
     /// Saved data Horizon keeps but does not simulate (save.rs).
-    pub saved: Option<Arc<crate::save::ChunkExtras>>,
+    pub saved: Option<Arc<ChunkExtras>>,
     /// Entities read from a save (vanilla entity NBT), spawned on arrival.
     pub entities: Vec<horizon_world::nbt::Tag>,
     /// Structure starts reaching into this chunk (`structures.References`):
@@ -309,6 +310,76 @@ impl Chunk {
     }
 }
 
+/// A proto chunk saved before it became final. Decoration writes into a
+/// chunk's neighbours, and decorated chunks wait for theirs, so the chunks
+/// past the finished ones hold writes that generating them again would lose
+/// (whole structure pieces, trees, ores). Vanilla saves its proto chunks too.
+pub struct SavedProto {
+    /// Blocks, scheduled ticks (in `saved`) and post-processing marks.
+    pub column: Chunk,
+    /// Decorated itself (`features`), not only written to by its neighbours
+    /// (`terrain`).
+    pub decorated: bool,
+    /// Block entity data in placement order, with `x`, `y` and `z`.
+    pub block_entities: Vec<Tag>,
+    /// Entities placed by structures, with absolute `Pos`.
+    pub entities: Vec<Tag>,
+}
+
+/// A container's loot table and what Horizon rolled from it. Vanilla keeps
+/// `LootTable` and `LootTableSeed` until the container is first opened;
+/// Horizon rolls when it generates or loads the chunk, and saves the table
+/// again while the container still holds exactly the rolled items.
+#[derive(Clone, Debug, PartialEq)]
+pub struct RolledLoot {
+    pub pos: (i32, i32, i32),
+    pub table: String,
+    /// The saved `LootTableSeed`, written back unless 0 (trySaveLootTable).
+    pub seed: Option<i64>,
+    /// The rolled `Items`.
+    pub items: Tag,
+}
+impl RolledLoot {
+    /// Puts the loot table back in place of `Items` while they are still the
+    /// roll; false once the container holds anything else.
+    pub fn restore(&self, map: &mut Compound) -> bool {
+        if map.get(&"Items".into()) != Some(&self.items) {
+            return false;
+        }
+        map.remove(&"Items".into());
+        map.insert("LootTable".into(), Tag::String(self.table.as_str().into()));
+        if let Some(seed) = self.seed.filter(|s| *s != 0) {
+            map.insert("LootTableSeed".into(), Tag::Long(seed));
+        }
+        true
+    }
+}
+
+/// Save data loaded with a chunk that Horizon keeps but does not simulate.
+#[derive(Clone, Debug, Default)]
+pub struct ChunkExtras {
+    /// Chunk root keys written back as loaded (structures, PostProcessing,
+    /// InhabitedTime, blending data, ...).
+    pub root: Compound,
+    /// Block entities Horizon does not model.
+    pub block_entities: Vec<Tag>,
+    /// The NBT of the modelled block entities as loaded, to restore the fields and
+    /// detail Horizon does not model when it saves them (`block_entity_nbt::overlay`).
+    pub block_entity_sources: Vec<((i32, i32, i32), Tag)>,
+    /// Every saved block entity's position in the order of the save's list,
+    /// the order `SerializableChunkData` puts them in the chunk's maps.
+    pub block_entity_order: Vec<(i32, i32, i32)>,
+    /// Scheduled ticks (`block_ticks`/`fluid_ticks`): delays relative to the
+    /// save time. Registered with the level's tick scheduler on arrival and
+    /// replaced with the scheduler's pending ticks when saving.
+    pub block_ticks: Vec<horizon_core::ticks::SavedTick>,
+    pub fluid_ticks: Vec<horizon_core::ticks::SavedTick>,
+    /// Game time written as `LastUpdate`.
+    pub last_update: i64,
+    /// Containers still holding their loot table's roll.
+    pub rolled_loot: Vec<RolledLoot>,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/horizon-client/src/chunk_map.rs b/crates/horizon-client/src/chunk_map.rs
index ed25491c5..fddded9e1 100644
--- a/crates/horizon-client/src/chunk_map.rs
+++ b/crates/horizon-client/src/chunk_map.rs
@@ -76,14 +76,11 @@ impl<'a> IntoIterator for &'a ChunkMap {
     }
 }
 impl crate::light::LightWorld for ChunkMap {
-    fn state(&self, x: i32, y: i32, z: i32) -> Option<u32> {
-        self.columns.state(x, y, z)
+    fn section(&self, cx: i32, s: usize, cz: i32) -> Option<&Arc<crate::chunk::Section>> {
+        self.columns.section(cx, s, cz)
     }
-    fn light(&self, x: i32, y: i32, z: i32) -> Option<u8> {
-        self.columns.light(x, y, z)
-    }
-    fn set_light(&mut self, x: i32, y: i32, z: i32, packed: u8) {
-        self.columns.set_light(x, y, z, packed);
+    fn set_section_light(&mut self, cx: i32, s: usize, cz: i32, light: crate::chunk::Light) {
+        self.columns.set_section_light(cx, s, cz, light);
     }
 }
 
@@ -106,7 +103,13 @@ mod tests {
         for column in map.values_mut() {
             Arc::make_mut(column).light_loaded = true;
         }
-        crate::light::LightWorld::set_light(&mut map, 0, 0, 0, 0);
+        crate::light::LightWorld::set_section_light(
+            &mut map,
+            0,
+            0,
+            0,
+            crate::chunk::Light::Uniform(0),
+        );
         assert_eq!(inserted, map.membership_revision());
         map.remove(&(0, 0));
         map.insert((1, 0), chunk);
diff --git a/crates/horizon-client/src/clouds.rs b/crates/horizon-client/src/clouds.rs
index 70f29c132..5e9bb731a 100644
--- a/crates/horizon-client/src/clouds.rs
+++ b/crates/horizon-client/src/clouds.rs
@@ -179,6 +179,8 @@ impl Mesh {
                         layer: 4,
                         color: u32::MAX,
                         light: shade,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             };
diff --git a/crates/horizon-client/src/collisions.rs b/crates/horizon-client/src/collisions.rs
index 7c32bd829..d35a1adfa 100644
--- a/crates/horizon-client/src/collisions.rs
+++ b/crates/horizon-client/src/collisions.rs
@@ -54,6 +54,27 @@ fn strider_liquid_shape() -> VoxelShape {
     VoxelShape::from_cube([1, 2, 1], &[true, false]).expect("a valid half-block column")
 }
 
+// Vanilla scopes this direction to Entity.move while a piston pushes it.
+thread_local! {
+    static PISTON_NOCLIP: std::cell::Cell<Option<horizon_core::geometry::Direction>> = const { std::cell::Cell::new(None) };
+}
+
+/// Suppress the moving part of pistons moving in this direction during a push.
+pub fn with_piston_noclip<T>(
+    direction: horizon_core::geometry::Direction,
+    f: impl FnOnce() -> T,
+) -> T {
+    struct Reset(Option<horizon_core::geometry::Direction>);
+    impl Drop for Reset {
+        fn drop(&mut self) {
+            PISTON_NOCLIP.with(|value| value.set(self.0));
+        }
+    }
+    let previous = PISTON_NOCLIP.with(|value| value.replace(Some(direction)));
+    let _reset = Reset(previous);
+    f()
+}
+
 pub struct SceneCollisions<'w, 'r> {
     pub world: &'w World,
     pub binding: &'w BlockCollisionRegistry<'r>,
@@ -140,8 +161,21 @@ impl<W: EntityMovementWorld<Error = io::Error>> EntityMovementWorld for EntityCo
         border.collision_shape().map(Some).map_err(io::Error::other)
     }
 }
-impl EntityCollisions<'_, SceneCollisions<'_, '_>> {
-    /// `SceneCollisions::resolve` that also stops at the entity boxes.
+impl<'a, W> EntityCollisions<'a, W>
+where
+    W: BlockCollisionWorld<Error = io::Error> + EntityMovementWorld<Error = io::Error>,
+{
+    /// `EntityCollisions` for a body the world border also stops: the border
+    /// and the body's own x and z (`WorldBorder.isInsideCloseToBorder`).
+    pub fn with_border(blocks: W, border: &'a BorderGeometry, at: [f64; 2]) -> Self {
+        Self {
+            blocks,
+            entities: &[],
+            border: Some((border, at)),
+        }
+    }
+    /// `SceneCollisions::resolve` that also stops at the entity boxes and,
+    /// with a border, at the world border's walls.
     pub fn resolve(
         &mut self,
         bounds: Aabb,
@@ -149,12 +183,11 @@ impl EntityCollisions<'_, SceneCollisions<'_, '_>> {
         max_step: f32,
         on_ground: bool,
     ) -> Result<Vec3> {
-        let context = self.blocks.context(bounds);
         Ok(resolve_world_movement(
             self,
             MovementRequest {
                 entity: EntityIdentity(0),
-                context,
+                context: CollisionContext::position(bounds.min_position().y),
                 bounds,
                 movement,
                 max_step,
@@ -324,7 +357,7 @@ impl DynamicSupportWorld for SceneCollisions<'_, '_> {
             return Ok(None);
         };
         pistons
-            .collision_shape(self, p, piston, None)
+            .collision_shape(self, p, piston, PISTON_NOCLIP.with(|value| value.get()))
             .map(Some)
             .map_err(io::Error::other)
     }
@@ -388,6 +421,42 @@ impl PowderSnowWorld for SceneCollisions<'_, '_> {
     }
 }
 
+/// A collision world without blocks: no chunk is resident, so only the
+/// world border stops a body.
+pub struct EmptyCollisions;
+
+impl BlockCollisionWorld for EmptyCollisions {
+    type Error = io::Error;
+    type Chunk = ChunkPos;
+    fn collision_chunk(&mut self, _: ChunkPos) -> io::Result<Option<ChunkPos>> {
+        Ok(None)
+    }
+    fn collision_block(&mut self, _: ChunkPos, _: BlockPos) -> io::Result<CollisionBlock> {
+        Err(io::Error::other("no chunk is resident"))
+    }
+    fn is_suffocating(&mut self, _: ChunkPos, _: CollisionBlock, _: BlockPos) -> io::Result<bool> {
+        Ok(false)
+    }
+    fn context_shape(
+        &mut self,
+        _: CollisionBlock,
+        _: BlockPos,
+        _: &CollisionContext<'_>,
+    ) -> io::Result<VoxelShape> {
+        Ok(VoxelShape::empty())
+    }
+}
+
+impl EntityMovementWorld for EmptyCollisions {
+    type Error = io::Error;
+    fn entity_collisions(&mut self, _: EntityIdentity, _: Aabb) -> io::Result<Vec<VoxelShape>> {
+        Ok(Vec::new())
+    }
+    fn movement_border(&mut self, _: EntityIdentity, _: Aabb) -> io::Result<Option<VoxelShape>> {
+        Ok(None)
+    }
+}
+
 /// Collision queries over any block lookup (test worlds without chunks):
 /// every chunk is present, nothing is suffocating, no entities collide.
 pub struct LookupCollisions<'w, 'r> {
@@ -475,3 +544,70 @@ impl PowderSnowWorld for LookupCollisions<'_, '_> {
         Ok(false)
     }
 }
+
+#[cfg(test)]
+mod piston_noclip_tests {
+    use super::*;
+    use horizon_core::geometry::Direction;
+
+    #[test]
+    fn piston_noclip_is_scoped_and_restored_after_unwind() {
+        assert_eq!(PISTON_NOCLIP.with(|value| value.get()), None);
+        with_piston_noclip(Direction::East, || {
+            assert_eq!(
+                PISTON_NOCLIP.with(|value| value.get()),
+                Some(Direction::East)
+            );
+            let _ =
+                std::panic::catch_unwind(|| with_piston_noclip(Direction::West, || panic!("test")));
+            assert_eq!(
+                PISTON_NOCLIP.with(|value| value.get()),
+                Some(Direction::East)
+            );
+        });
+        assert_eq!(PISTON_NOCLIP.with(|value| value.get()), None);
+    }
+}
+
+#[cfg(test)]
+mod border_movement_tests {
+    use super::*;
+
+    /// A border 10 wide around the origin: its wall's inner face is at x = 5.
+    fn border() -> BorderGeometry {
+        BorderGeometry::new([0.0, 0.0], 10.0, 29_999_984).expect("a border")
+    }
+
+    /// `WorldBorder.isInsideCloseToBorder` and `WorldBorder.getCollisionShape`:
+    /// a body inside close to the border collides with the border's walls.
+    #[test]
+    fn a_body_next_to_the_border_stops_at_its_wall() {
+        // A body 0.6 wide, 0.4 blocks short of the wall, moved east into it.
+        let bounds = Aabb::new(Vec3::new(4.0, 0.0, 0.0), Vec3::new(4.6, 1.8, 0.6));
+        let border = border();
+        let mut collisions = EntityCollisions::with_border(EmptyCollisions, &border, [4.3, 0.3]);
+        let moved = collisions
+            .resolve(bounds, Vec3::new(0.51, 0.0, 0.0), 0.0, false)
+            .expect("the movement resolves");
+        // The wall stops the body 0.4 blocks short of the whole move.
+        assert!(
+            (moved.x - 0.4).abs() < 1.0e-9,
+            "the body was not stopped by the border: {moved:?}"
+        );
+    }
+
+    /// Away from the border, the same body moves the whole way.
+    #[test]
+    fn a_body_away_from_the_border_moves_whole() {
+        let bounds = Aabb::new(Vec3::new(0.0, 0.0, 0.0), Vec3::new(0.6, 1.8, 0.6));
+        let border = border();
+        let mut collisions = EntityCollisions::with_border(EmptyCollisions, &border, [0.3, 0.3]);
+        let moved = collisions
+            .resolve(bounds, Vec3::new(0.51, 0.0, 0.0), 0.0, false)
+            .expect("the movement resolves");
+        assert!(
+            (moved.x - 0.51).abs() < 1.0e-9,
+            "the body did not move the whole way: {moved:?}"
+        );
+    }
+}
diff --git a/crates/horizon-client/src/command_block.rs b/crates/horizon-client/src/command_block.rs
index 942e11ab6..47f808932 100644
--- a/crates/horizon-client/src/command_block.rs
+++ b/crates/horizon-client/src/command_block.rs
@@ -35,6 +35,23 @@ impl Mode {
             Self::Redstone => "minecraft:command_block",
         }
     }
+    /// `Enum.ordinal`, which `ServerboundSetCommandBlockPacket` writes.
+    pub fn ordinal(self) -> i32 {
+        match self {
+            Self::Sequence => 0,
+            Self::Auto => 1,
+            Self::Redstone => 2,
+        }
+    }
+    /// The mode of a packet's ordinal; `handleSetCommandBlock` treats any
+    /// other value as a plain command block (its `default` branch).
+    pub fn from_ordinal(ordinal: i32) -> Self {
+        match ordinal {
+            0 => Self::Sequence,
+            1 => Self::Auto,
+            _ => Self::Redstone,
+        }
+    }
     /// `CycleButton`: the next value, wrapping round.
     pub fn next(self) -> Self {
         match self {
diff --git a/crates/horizon-client/src/container_screen.rs b/crates/horizon-client/src/container_screen.rs
index 77c7ad8aa..a7b1794c5 100644
--- a/crates/horizon-client/src/container_screen.rs
+++ b/crates/horizon-client/src/container_screen.rs
@@ -124,6 +124,18 @@ impl Clicks {
         self.skip_next_release = true;
     }
 
+    /// The screen that takes the pointer over starts with its own state:
+    /// `AbstractContainerScreen` holds `isQuickCrafting` and the drag it
+    /// belongs to on the screen, so a screen that opens (or closes) drops
+    /// them. A press whose release never arrived -- the pointer left the
+    /// window -- would otherwise keep the drag running, and `press` answers
+    /// `None` for every later press, so the quick move and the clicks go
+    /// dead on every screen after it.
+    pub fn cancel_drag(&mut self) {
+        self.quick_crafting = None;
+        self.skip_next_release = false;
+    }
+
     /// `mouseClicked` (no double click): the `slotClicked` input it sends on
     /// `target`, if any. A press holding a stack starts a quick craft drag
     /// instead. `cloning` is `keyPickItem` with infinite materials.
@@ -301,4 +313,35 @@ mod tests {
             Some(Input::Pickup)
         );
     }
+
+    /// #1737: a press whose release never arrives (the pointer left the
+    /// window) leaves `isQuickCrafting` set, and `press` answers `None` for
+    /// every later press, so the Shift quick move and the clicks on the
+    /// inventory go dead. The drag belongs to the screen that has it
+    /// (`AbstractContainerScreen` holds `isQuickCrafting`), so the screen
+    /// that takes the pointer over drops it and the quick move works again.
+    #[test]
+    fn a_lost_release_does_not_wedge_the_quick_move() {
+        let mut clicks = Clicks::default();
+        let slot = Target::<usize>::Slot(3);
+        // Pressed with a stack carried: a quick craft drag starts, and its
+        // release never arrives.
+        assert_eq!(clicks.press(&slot, Button::Left, false, false, false), None);
+        assert!(clicks.quick_crafting().is_some());
+        // The stuck drag swallows the next press: the Shift quick move stops
+        // working and the inventory stops answering.
+        assert_eq!(clicks.press(&slot, Button::Right, true, true, false), None);
+        // The screen that takes the pointer over starts with its own state.
+        clicks.cancel_drag();
+        assert!(clicks.quick_crafting().is_none());
+        // The quick move works again.
+        assert_eq!(
+            clicks.press(&slot, Button::Right, true, true, false),
+            Some(Input::QuickMove)
+        );
+        assert_eq!(
+            clicks.press(&slot, Button::Left, true, false, false),
+            Some(Input::Pickup)
+        );
+    }
 }
diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs
index 6aba0970e..ed7d09a60 100644
--- a/crates/horizon-client/src/containers.rs
+++ b/crates/horizon-client/src/containers.rs
@@ -98,6 +98,18 @@ pub enum BlockEntity {
     Campfire(Box<Campfire>),
     /// `SkullBlockEntity` of every skull and head block.
     Skull(Skull),
+    /// `TheEndGatewayBlockEntity`: its age and configured destination.
+    EndGateway(EndGateway),
+    /// `DaylightDetectorBlockEntity`: no data, only the ticker
+    /// (`DaylightDetectorBlock.tickEntity`).
+    DaylightDetector,
+}
+/// `TheEndGatewayBlockEntity`.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct EndGateway {
+    pub age: i64,
+    pub exit_portal: Option<[i32; 3]>,
+    pub exact_teleport: bool,
 }
 /// `CampfireBlockEntity`: four cooking slots, each with its
 /// `cookingProgress` and `cookingTime` (the recipe's).
@@ -187,6 +199,9 @@ impl Skull {
 #[derive(Clone, Debug)]
 pub struct SkullSkin {
     pub download: Option<(String, String)>,
+    /// `ResolvableProfile.nameOrId` when the profile is `Dynamic` (a name or
+    /// an id only): the key `skins::Resolver` resolves it by.
+    pub dynamic: Option<crate::skins::NameOrId>,
     pub fallback: &'static str,
 }
 impl SkullSkin {
@@ -195,10 +210,21 @@ impl SkullSkin {
             let location = crate::skins::skin_location(&crate::skins::texture_hash(&url)?);
             Some((url, location))
         });
+        // A `Dynamic` profile (a name or id only) resolves through the
+        // services when the skull is drawn.
+        let dynamic = crate::skins::dynamic_nbt(profile);
         // DefaultPlayerSkin.get(id), or getDefaultSkin (slim steve) without an id.
         let fallback = crate::skins::profile_uuid_nbt(profile)
+            .or_else(|| {
+                crate::skins::nbt_text(profile.get("name"))
+                    .map(|name| horizon_protocol::crypto::offline_uuid(&name))
+            })
             .map_or("entity/player/slim/steve", crate::tab_list::default_skin);
-        Self { download, fallback }
+        Self {
+            download,
+            dynamic,
+            fallback,
+        }
     }
 }
 /// The skull and head blocks (`SkullBlock`, `WallSkullBlock`): every
@@ -363,6 +389,12 @@ impl BlockEntity {
         if is_skull(name) {
             return Some(Self::Skull(Skull::default()));
         }
+        if name == "minecraft:end_gateway" {
+            return Some(Self::EndGateway(EndGateway::default()));
+        }
+        if name == "minecraft:daylight_detector" {
+            return Some(Self::DaylightDetector);
+        }
         if name == "minecraft:beacon" {
             return Some(Self::Beacon(Box::new(Beacon {
                 last_check_y: i32::MIN / 2,
@@ -412,6 +444,8 @@ impl BlockEntity {
             Self::Beehive(_) => "minecraft:beehive",
             Self::CommandBlock(_) => "minecraft:command_block",
             Self::Skull(_) => "minecraft:skull",
+            Self::EndGateway(_) => "minecraft:end_gateway",
+            Self::DaylightDetector => "minecraft:daylight_detector",
             Self::Campfire(_) => "minecraft:campfire",
         }
     }
@@ -429,7 +463,9 @@ impl BlockEntity {
             | Self::Vault(_)
             | Self::Beehive(_)
             | Self::CommandBlock(_)
-            | Self::Skull(_) => Vec::new(),
+            | Self::EndGateway(_)
+            | Self::Skull(_)
+            | Self::DaylightDetector => Vec::new(),
             Self::Lectern(l) => l.book.iter().cloned().collect(),
             Self::Sculk(_) => Vec::new(),
             Self::Banner(_) => Vec::new(),
@@ -448,7 +484,9 @@ impl BlockEntity {
             | Self::Lectern(_)
             | Self::Sculk(_)
             | Self::Banner(_)
-            | Self::Skull(_) => &[],
+            | Self::EndGateway(_)
+            | Self::Skull(_)
+            | Self::DaylightDetector => &[],
             Self::Crafter(c) => &c.items,
             Self::CreakingHeart(_)
             | Self::Spawner(_)
@@ -471,7 +509,9 @@ impl BlockEntity {
             | Self::Lectern(_)
             | Self::Sculk(_)
             | Self::Banner(_)
-            | Self::Skull(_) => &mut [],
+            | Self::EndGateway(_)
+            | Self::Skull(_)
+            | Self::DaylightDetector => &mut [],
             Self::Crafter(c) => &mut c.items,
             Self::CreakingHeart(_)
             | Self::Spawner(_)
@@ -718,6 +758,18 @@ impl Furnace {
                                     .recipes_used
                                     .entry(recipe_used_key(&recipe.id))
                                     .or_insert(0) += 1;
+                                // AbstractFurnaceBlockEntity.burn: drying a wet sponge fills
+                                // the bucket in the fuel slot.
+                                if self.items[0]
+                                    .as_ref()
+                                    .is_some_and(|i| &*i.item == "minecraft:wet_sponge")
+                                    && self.items[1]
+                                        .as_ref()
+                                        .is_some_and(|f| &*f.item == "minecraft:bucket")
+                                {
+                                    self.items[1] =
+                                        Some(ItemStack::new("minecraft:water_bucket", 1));
+                                }
                                 if let Some(i) = self.items[0].as_mut() {
                                     i.count -= 1;
                                     if i.count == 0 {
diff --git a/crates/horizon-client/src/effects.rs b/crates/horizon-client/src/effects.rs
index 17dce93ab..9511fd112 100644
--- a/crates/horizon-client/src/effects.rs
+++ b/crates/horizon-client/src/effects.rs
@@ -2,7 +2,7 @@
 //! add/update with hidden effects, per-tick application of the periodic
 //! effects (regeneration, poison, wither, hunger, saturation, instant
 //! effects), and the derived flags the movement and damage code read.
-use crate::brewing;
+use horizon_client_core::potions;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct EffectInstance {
@@ -179,13 +179,14 @@ impl PlayerEffects {
         self.list.clear();
     }
     /// The effects of a saved player (`Player.active_effects`: id,
-    /// duration, amplifier, ambient, visible).
+    /// duration, amplifier, ambient, particles visible).
     pub fn from_saved(saved: &[(String, i32, i32, bool, bool)]) -> Self {
         let mut effects = Self::default();
-        for (id, duration, amplifier, ambient, _) in saved {
-            if let Some(def) = brewing::effect(id) {
+        for (id, duration, amplifier, ambient, particles) in saved {
+            if let Some(def) = potions::effect(id) {
                 let mut e = EffectInstance::new(def.id, *duration, *amplifier);
                 e.ambient = *ambient;
+                e.visible = *particles;
                 effects.add(e);
             }
         }
@@ -213,8 +214,9 @@ impl PlayerEffects {
     }
     /// `LivingEntity.tickEffects` (server part) with the omens' effect ticks:
     /// `omen` answers `BadOmenMobEffect` (every tick) and `RaidOmenMobEffect`
-    /// (on its last tick). Returns the actions to apply, in order, and
-    /// whether Raid Omen was newly added.
+    /// (on its last tick); `absorption_empty` is `AbsorptionMobEffect`'s
+    /// answer: the effect ends once the absorption is used up. Returns the
+    /// actions to apply, in order, and whether Raid Omen was newly added.
     ///
     /// Bad Omen turning into a new Raid Omen adds an entry to the map being
     /// iterated: vanilla's iterator then throws a
@@ -224,6 +226,7 @@ impl PlayerEffects {
     pub fn tick_with(
         &mut self,
         omen: &mut dyn FnMut(&EffectInstance) -> OmenTick,
+        absorption_empty: bool,
     ) -> (Vec<EffectAction>, bool) {
         self.tick_count = self.tick_count.wrapping_add(1);
         let mut actions = Vec::new();
@@ -246,6 +249,7 @@ impl PlayerEffects {
             let answer = match e.id {
                 "bad_omen" => omen(e),
                 "raid_omen" if t == 1 => omen(e),
+                "absorption" if absorption_empty => OmenTick::Remove,
                 _ => OmenTick::Continue,
             };
             match answer {
@@ -302,10 +306,10 @@ impl PlayerEffects {
     ) -> (Vec<EffectInstance>, Vec<EffectAction>) {
         let mut lasting = Vec::new();
         let mut now = Vec::new();
-        if let Some(def) = potion.and_then(brewing::potion) {
+        if let Some(def) = potion.and_then(potions::potion) {
             for (id, duration, amp) in def.effects {
-                let id = brewing::effect(id).map_or("speed", |e| e.id);
-                if brewing::effect(id).is_some_and(|e| e.instant) {
+                let id = potions::effect(id).map_or("speed", |e| e.id);
+                if potions::effect(id).is_some_and(|e| e.instant) {
                     now.extend(instant(id, *amp, 1.0));
                 } else {
                     // withScaledDuration: max(floor(d * scale), 1).
@@ -465,13 +469,13 @@ mod tests {
         };
         // The first tick adds Raid Omen and stops there (the iterator's
         // ConcurrentModificationException): Bad Omen and Speed stay as they were.
-        let (_, added) = fx.tick_with(&mut convert);
+        let (_, added) = fx.tick_with(&mut convert, false);
         assert!(added);
         assert_eq!(fx.get("bad_omen").unwrap().duration, 100);
         assert_eq!(fx.get("speed").unwrap().duration, 50);
         assert_eq!(fx.get("raid_omen").unwrap().duration, 600);
         // The second refreshes Raid Omen and drops Bad Omen.
-        let (_, added) = fx.tick_with(&mut convert);
+        let (_, added) = fx.tick_with(&mut convert, false);
         assert!(!added);
         assert!(fx.get("bad_omen").is_none());
         assert_eq!(fx.get("speed").unwrap().duration, 49);
@@ -486,9 +490,9 @@ mod tests {
             seen.push(e.duration);
             OmenTick::Remove
         };
-        fx.tick_with(&mut watch);
+        fx.tick_with(&mut watch, false);
         assert!(fx.get("raid_omen").is_some());
-        fx.tick_with(&mut watch);
+        fx.tick_with(&mut watch, false);
         assert!(fx.get("raid_omen").is_none());
         assert_eq!(seen, vec![1]);
     }
diff --git a/crates/horizon-client/src/enchant.rs b/crates/horizon-client/src/enchant.rs
index 2f418ae82..73b9bf090 100644
--- a/crates/horizon-client/src/enchant.rs
+++ b/crates/horizon-client/src/enchant.rs
@@ -545,6 +545,32 @@ impl Enchantments {
         }
         out
     }
+    /// `EnchantmentHelper.forEachModifier` as an item's tooltip lists them: the
+    /// `minecraft:attributes` effects of `stack`'s enchantments as rows of
+    /// (attribute, id, amount, operation, slot group), one per slot group the
+    /// enchantment lists.
+    pub fn modifier_rows(&self, stack: &ItemStack) -> Vec<(String, String, f64, String, String)> {
+        let mut rows = Vec::new();
+        for (id, level) in stack.enchantments() {
+            let Some(e) = self.get(id) else { continue };
+            for a in e.effects["minecraft:attributes"]
+                .as_array()
+                .into_iter()
+                .flatten()
+            {
+                for slot in &e.slots {
+                    rows.push((
+                        a["attribute"].as_str().unwrap_or("").to_owned(),
+                        a["id"].as_str().unwrap_or("").to_owned(),
+                        f64::from(level_value(&a["amount"], *level)),
+                        a["operation"].as_str().unwrap_or("add_value").to_owned(),
+                        slot.clone(),
+                    ));
+                }
+            }
+        }
+        rows
+    }
     /// Sum of `add_value` amounts of one attribute from enchantments on `stack`.
     pub fn attribute_add(&self, stack: Option<&ItemStack>, attribute: &str) -> f64 {
         stack.map_or(0.0, |s| {
diff --git a/crates/horizon-client/src/entities.rs b/crates/horizon-client/src/entities.rs
index 69e053411..14cd946c2 100644
--- a/crates/horizon-client/src/entities.rs
+++ b/crates/horizon-client/src/entities.rs
@@ -95,6 +95,15 @@ impl ItemEntity {
                 self.health -= fire_damage as i32;
             }
         }
+        // CactusBlock.entityInside: `entity.hurt(cactus, 1.0)`. An item has no
+        // hurt cooldown, so it loses 1 health every tick it touches a cactus
+        // (5 health: gone in 5 ticks). Fire resistance does not help;
+        // `ItemStack.canBeHurtBy` only skips it for a damage_resistant stack.
+        if crate::motion::environment::cactus_contact(world, registry, self.bounds())
+            && !items.resists_cactus(&self.stack)
+        {
+            self.health -= 1;
+        }
         ItemEnvironmentTick {
             alive: self.health > 0,
             lava_hurt,
@@ -385,8 +394,29 @@ pub struct ExperienceOrb {
     pub value: u32,
     pub age: u32,
     pub on_ground: bool,
+    /// `ExperienceOrb.count`: orbs merged into this one; each pickup gives
+    /// `value` once and takes one off.
+    pub count: u32,
+    /// `Entity.tickCount`, which paces `ExperienceOrb.scanForMerges`.
+    pub ticks: u32,
 }
 impl ExperienceOrb {
+    pub fn bounds(&self) -> Aabb {
+        let h = 0.25;
+        Aabb::new(
+            Vec3::new(self.position.x - h, self.position.y, self.position.z - h),
+            Vec3::new(
+                self.position.x + h,
+                self.position.y + 0.5,
+                self.position.z + h,
+            ),
+        )
+    }
+    /// `ExperienceOrb.canMerge(orb, id, value)` for an orb that is not removed:
+    /// the same value and ids a multiple of 40 apart.
+    pub fn can_merge(&self, id: u32, value: u32) -> bool {
+        self.value == value && (self.id as i32).wrapping_sub(id as i32) % 40 == 0
+    }
     /// ExperienceOrb.getExperienceValue: the largest orb size not above `value`.
     pub fn split(value: u32) -> u32 {
         [2477, 1237, 617, 307, 149, 73, 37, 17, 7, 3, 1]
@@ -416,7 +446,9 @@ impl ExperienceOrb {
         facts: &BlockFacts,
         collision: &BlockCollisionRegistry<'_>,
         player: Option<[f64; 3]>,
+        next_float: &mut dyn FnMut() -> f32,
     ) -> bool {
+        self.ticks += 1;
         self.previous = self.position;
         let block = world.block(
             self.position.x.floor() as i32,
@@ -432,6 +464,14 @@ impl ExperienceOrb {
         } else {
             self.velocity.y -= 0.03;
         }
+        if facts.get(block).fluid == Fluid::Lava {
+            // ExperienceOrb.tick: lava throws the orb back out.
+            self.velocity = Vec3::new(
+                f64::from((next_float() - next_float()) * 0.2),
+                f64::from(0.2f32),
+                f64::from((next_float() - next_float()) * 0.2),
+            );
+        }
         if let Some(p) = player {
             let d = [
                 (p[0] - self.position.x) / 8.0,
@@ -449,15 +489,7 @@ impl ExperienceOrb {
                 );
             }
         }
-        let h = 0.25;
-        let bounds = Aabb::new(
-            Vec3::new(self.position.x - h, self.position.y, self.position.z - h),
-            Vec3::new(
-                self.position.x + h,
-                self.position.y + 0.5,
-                self.position.z + h,
-            ),
-        );
+        let bounds = self.bounds();
         let mut scene = SceneCollisions {
             world,
             binding: collision,
@@ -494,6 +526,31 @@ impl ExperienceOrb {
         self.age < 6000
     }
 }
+/// `ExperienceOrb.scanForMerges`, run by each orb on `tickCount % 20 == 1`:
+/// it absorbs the orbs that `canMerge` within 0.5 blocks of its box,
+/// adding their counts and keeping the smaller age.
+pub fn merge_orbs(orbs: &mut Vec<ExperienceOrb>) {
+    let mut removed = vec![false; orbs.len()];
+    for i in 0..orbs.len() {
+        if removed[i] || orbs[i].ticks % 20 != 1 {
+            continue;
+        }
+        let area = orbs[i].bounds().inflate(Vec3::new(0.5, 0.5, 0.5));
+        for j in 0..orbs.len() {
+            if j != i
+                && !removed[j]
+                && orbs[j].can_merge(orbs[i].id, orbs[i].value)
+                && orbs[j].bounds().intersects(area)
+            {
+                orbs[i].count += orbs[j].count;
+                orbs[i].age = orbs[i].age.min(orbs[j].age);
+                removed[j] = true;
+            }
+        }
+    }
+    let mut removed = removed.into_iter();
+    orbs.retain(|_| !removed.next().unwrap_or(false));
+}
 /// Player experience (Player.giveExperiencePoints / getXpNeededForNextLevel).
 #[derive(Clone, Copy, Debug, Default)]
 pub struct Experience {
@@ -525,17 +582,21 @@ impl Experience {
             7 + level * 2
         }
     }
-    /// Returns true when a level was gained.
-    pub fn give(&mut self, points: i32) -> bool {
-        let start = self.level;
+    /// Returns the first multiple of 5 the player reached, where each level
+    /// gained would play the level-up sound (`Player.giveExperienceLevels`).
+    pub fn give(&mut self, points: i32) -> Option<i32> {
+        let mut sound_level = None;
         self.progress += points as f32 / Self::needed(self.level) as f32;
         self.total = self.total.saturating_add(points).max(0);
         while self.progress >= 1.0 {
             self.progress = (self.progress - 1.0) * Self::needed(self.level) as f32;
             self.level += 1;
+            if self.level % 5 == 0 {
+                sound_level.get_or_insert(self.level);
+            }
             self.progress /= Self::needed(self.level) as f32;
         }
-        self.level > start
+        sound_level
     }
 }
 /// A painting (`Painting`, a `HangingEntity`): the block it hangs in, the
diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl
index 79e11719f..e90b9dd66 100644
--- a/crates/horizon-client/src/entity.wgsl
+++ b/crates/horizon-client/src/entity.wgsl
@@ -14,7 +14,8 @@ struct Globals {
     // Atlas rects (u0, v0, width, height) of end_sky.png and end_portal.png.
     end_portal_sprites: array<vec4<f32>, 2>,
     // x: vanilla's GameTime ((game time % 24000 + partial tick) / 24000)
-    // y: Nether cardinal lighting, z: how many dynamic_lights are set.
+    // y: Nether cardinal lighting, z: how many dynamic_lights are set,
+    // w: the glint scroll clock (`Glint::scroll_ticks`).
     time: vec4<f32>,
     crumbling_sprite: vec4<f32>,
     // Selection outline parameters (read by terrain.wgsl).
@@ -27,6 +28,12 @@ struct Globals {
 @group(0) @binding(2) var atlas_sampler: sampler;
 @group(0) @binding(3) var lightmap: texture_2d<f32>;
 @group(0) @binding(4) var lightmap_sampler: sampler;
+// enchanted_glint_item on its own repeating texture (vanilla's GlintSampler).
+@group(0) @binding(5) var glint_tex: texture_2d<f32>;
+@group(0) @binding(6) var glint_sampler: sampler;
+// The armour layers' GlintSampler: vanilla samples enchanted_glint_armor with
+// the same repeating, linearly filtered sampler as the item glint.
+@group(0) @binding(7) var glint_armor_tex: texture_2d<f32>;
 struct Out {
     @builtin(position) clip: vec4<f32>,
     @location(0) uv: vec2<f32>,
@@ -44,6 +51,9 @@ struct Out {
     // entity.vsh's lightMapColor, multiplied in after the overlay.
     @location(9) light_color: vec4<f32>,
     @location(10) @interpolate(flat) weather_rect: vec4<f32>,
+    // The `GLINT_TEXTURING` sample for overlay 7 (item foil), or the model UV
+    // `ARMOR_ENTITY_GLINT_TEXTURING` scrolls for overlay 13 (armour).
+    @location(11) glint_uv: vec2<f32>,
 }
 // Shipped light.glsl; normals are already transformed and RGBA8_SNORM packed.
 fn entity_light(normal: vec3<f32>, nether: bool) -> f32 {
@@ -103,18 +113,23 @@ fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
     out.spherical = select(length(position), 0.0, overlay >= 2u && overlay <= 4u);
     out.cylindrical = select(max(length(position.xz), abs(position.y)), 0.0, overlay >= 2u && overlay <= 4u);
     out.overlay = overlay;
+    out.glint_uv = vec2(0.0);
     if overlay == 4u { out.spherical = length(position); }
     return out;
 }
 @vertex fn vs_entity(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
-    @location(2) overlay: u32, @location(3) color: vec4<f32>, @location(4) light: vec4<u32>, @location(5) normal: vec4<f32>) -> Out {
-    return entity_vertex(position, uv, overlay, color, light, normal);
+    @location(2) overlay: u32, @location(3) color: vec4<f32>, @location(4) light: vec4<u32>,
+    @location(5) normal: vec4<f32>, @location(6) glint_uv: vec2<f32>) -> Out {
+    var out = entity_vertex(position, uv, overlay, color, light, normal);
+    out.glint_uv = glint_uv;
+    return out;
 }
 // Retained bolt-local geometry, translated using the same f64 camera
 // subtraction as the former CPU path before adding each local f32 position.
+// The bolt offset is instance attribute 7: 6 is the entity vertex's glint UV.
 @vertex fn vs_lightning(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
     @location(2) overlay: u32, @location(3) color: vec4<f32>, @location(4) light: vec4<u32>, @location(5) normal: vec4<f32>,
-    @location(6) offset: vec3<f32>) -> Out {
+    @location(7) offset: vec3<f32>) -> Out {
     return entity_vertex(offset + position, uv, overlay, color, light, normal);
 }
 struct CloudInfo {
@@ -166,6 +181,27 @@ fn linear_fog(d: f32, start: f32, end: f32) -> f32 {
     if d >= end { return 1.0; }
     return (d - start) / (end - start);
 }
+// TextureTransform.setupGlintTexturing(0.16), ARMOR_ENTITY_GLINT_TEXTURING.
+// globals.time.w is (Util.getMillis() * glintSpeed * 8) modulo 330000, the
+// common period of both offsets.
+fn armor_glint_uv(model: vec2<f32>) -> vec2<f32> {
+    let ticks = globals.time.w;
+    let offset0 = (ticks % 110000.0) / 110000.0;
+    let offset1 = (ticks % 30000.0) / 30000.0;
+    let angle = 0.17453292;
+    let c = cos(angle);
+    let s = sin(angle);
+    let scaled = model * 0.16;
+    return vec2(scaled.x * c - scaled.y * s - offset0,
+                scaled.x * s + scaled.y * c + offset1);
+}
+// RenderPipelines.GLINT: the source colour is scaled by itself, so `GlintAlpha`
+// is squared along with the sample.
+fn glint_over(color: vec4<f32>, glint: vec4<f32>) -> vec4<f32> {
+    let alpha = globals.fog_ends.w;
+    let g = alpha * glint;
+    return vec4(color.rgb + g.rgb * g.rgb, max(color.a, alpha));
+}
 // CRUMBLING_UV_BEGIN
 fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>, dimensions: vec2<u32>) -> vec2<f32> {
     let size = vec2<f32>(dimensions);
@@ -203,25 +239,60 @@ fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>,
     // lit texture, then the lightmap, then the glint and fog.
     color = vec4(mix(in.overlay_color.rgb, color.rgb, in.overlay_color.a), color.a);
     color *= in.light_color;
-    if in.overlay == 7u || in.overlay == 8u {
-        // Enchantment glint (overlay 7, 8 with the hurt tint): the purple
-        // enchanted_glint sheen drifting diagonally over the item's shape.
-        let px = in.uv * vec2<f32>(textureDimensions(atlas));
-        let t = globals.misc.y * 0.05;
-        let band = sin((px.x + px.y) * 0.9 - t * 6.0) * 0.5 + 0.5;
-        let band2 = sin((px.x - px.y) * 0.6 + t * 4.0) * 0.5 + 0.5;
-        let shimmer = pow(band * 0.6 + band2 * 0.4, 2.0);
-        let glint = vec3(0.50, 0.25, 0.80) * (0.25 + 0.75 * shimmer);
-        color = vec4(min(color.rgb + glint * 0.6, vec3(1.0)), color.a);
+    if in.overlay == 7u || in.overlay == 8u || in.overlay == 33u {
+        // 33: a translucent item with the glint.
+        // Enchantment glint: item.fsh's GLINT path, sampled from
+        // enchanted_glint_item at the `GLINT_TEXTURING` UV.
+        color = glint_over(color, textureSample(glint_tex, glint_sampler, in.glint_uv));
+    } else if in.overlay == 13u {
+        // Enchanted armour: enchanted_glint_armor at the scrolling model UV.
+        color = glint_over(
+            color,
+            textureSample(glint_armor_tex, glint_sampler, armor_glint_uv(in.glint_uv)),
+        );
     }
     let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
                 linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
     return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a);
 }
 
+// rendertype_outline.fsh: the vertex colour (the team colour; outline vertices carry no
+// normal, so no cardinal light) wherever the texture is not fully clear.
+@fragment fn fs_outline(in: Out) -> @location(0) vec4<f32> {
+    if textureSample(atlas, atlas_sampler, in.uv).a == 0.0 { discard; }
+    return vec4(in.color.rgb, 1.0);
+}
+
+fn celestial_color(in: Out) -> vec4<f32> {
+    return textureSample(atlas, atlas_sampler, in.uv) * in.color * in.light_color;
+}
 @fragment fn fs_celestial(in: Out) -> @location(0) vec4<f32> {
-    let color = textureSample(atlas, atlas_sampler, in.uv) * in.color * in.light_color;
-    return color;
+    return celestial_color(in);
+}
+
+// The sky's celestial pass (sun, moon, the End sky): fs_celestial's light,
+// premultiplied for an additive (one, one) blend, and as alpha how much of it
+// the texel adds, which the blend takes off the frame's alpha. HDR output
+// (hdr.wgsl) lifts only where that left it low: the sun's and moon's discs, not
+// the dark rest of their quads or the dim End sky.
+@fragment fn fs_sky_celestial(in: Out) -> @location(0) vec4<f32> {
+    let color = celestial_color(in);
+    let added = color.rgb * color.a;
+    return vec4(added, smoothstep(0.1, 0.3, max(added.r, max(added.g, added.b))));
+}
+
+// RenderPipelines.ENERGY_SWIRL (entity.fsh with EMISSIVE and NO_OVERLAY): the sprite, scrolled by
+// the UV and repeated within itself, times the layer colour 0xFF808080, unlit; the pipeline adds
+// it to the frame. The light bytes carry the sprite's origin and the colour bytes its size, both
+// as breaking::stage_light packs them.
+@fragment fn fs_energy_swirl(in: Out) -> @location(0) vec4<f32> {
+    let bytes = round(in.color * 255.0);
+    let size = vec2(bytes.x + bytes.y * 256.0, bytes.z + bytes.w * 256.0) / 65535.0;
+    let color = textureSample(atlas, atlas_sampler, crumbling_uv(in.uv, in.wrap, size, textureDimensions(atlas)));
+    if color.a < 0.1 { discard; }
+    let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
+                linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
+    return vec4(mix(color.rgb * (128.0 / 255.0), globals.fog_color.rgb, f * globals.fog_color.a), color.a);
 }
 
 // RenderPipelines.WATER_MASK: depth only (the pipeline masks the colour off).
diff --git a/crates/horizon-client/src/entity_culling.rs b/crates/horizon-client/src/entity_culling.rs
index 16de17465..0c309041a 100644
--- a/crates/horizon-client/src/entity_culling.rs
+++ b/crates/horizon-client/src/entity_culling.rs
@@ -186,6 +186,8 @@ mod tests {
             color: u32::MAX,
             light: 0,
             normal: [0; 4],
+
+            glint_uv: [0.0, 0.0],
         };
         let prior = vertex([0.0; 3]);
         let body = [vertex([8.0, -1.0, -1.0]), vertex([10.0, 1.0, 1.0])];
diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index 7f3565067..5c3d41ddc 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -180,7 +180,6 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         ("Silent", m.silent),
         ("NoGravity", m.no_gravity),
         ("Glowing", m.glowing),
-        ("Invulnerable", m.invulnerable_flag),
     ] {
         if on {
             map.insert(key.into(), Tag::Byte(1));
@@ -188,6 +187,51 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             map.remove(&horizon_world::nbt::JavaString::from(key));
         }
     }
+    // LivingEntity.addAdditionalSaveData: `active_effects` only when there are
+    // any (MobEffectInstance.CODEC; a mob's effects are never ambient, and one
+    // given with `hideParticles` shows neither particles nor its icon).
+    if m.extra.effects.is_empty() {
+        map.remove(&horizon_world::nbt::JavaString::from("active_effects"));
+    } else {
+        let effects = m
+            .extra
+            .effects
+            .iter()
+            .map(|&(effect, duration, amplifier)| {
+                let shown = !m.extra.hidden_effects.contains(&effect);
+                let mut e = vec![
+                    ("id", string(crate::brewing::namespaced(effect))),
+                    ("amplifier", Tag::Byte(amplifier.clamp(0, 255) as u8 as i8)),
+                    ("duration", Tag::Int(duration)),
+                ];
+                if !shown {
+                    e.push(("show_particles", Tag::Byte(0)));
+                }
+                e.push(("show_icon", Tag::Byte(i8::from(shown))));
+                Tag::compound(e)
+            });
+        map.insert("active_effects".into(), Tag::List(effects.collect()));
+    }
+    map.insert(
+        "Invulnerable".into(),
+        Tag::Byte(i8::from(m.invulnerable_flag)),
+    );
+    map.insert(
+        "LeftHanded".into(),
+        Tag::Byte(i8::from(m.extra.left_handed)),
+    );
+    // Keys of older formats that structure templates still carry.
+    for key in [
+        "HandItems",
+        "ArmorItems",
+        "HandDropChances",
+        "ArmorDropChances",
+        "Dimension",
+        "HurtByTimestamp",
+        "Leashed",
+    ] {
+        map.remove(&horizon_world::nbt::JavaString::from(key));
+    }
     if m.ticks_frozen > 0 {
         map.insert("TicksFrozen".into(), Tag::Int(m.ticks_frozen));
     } else {
@@ -197,7 +241,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         ("AbsorptionAmount", Tag::Float(0)),
         ("FallFlying", Tag::Byte(0)),
         ("CanPickUpLoot", Tag::Byte(i8::from(m.can_pick_up_loot()))),
-        ("LeftHanded", Tag::Byte(0)),
+        ("current_impulse_context_reset_grace_time", Tag::Int(0)),
         (
             "Brain",
             Tag::compound([("memories", Tag::Compound(Compound::new()))]),
@@ -209,7 +253,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
     // Only breedable animals have an age; a loaded creature that was saved without
     // one (a frog) stays without.
     let aged = raw.is_none_or(|r| r.get("Age").is_some());
-    if m.kind.category == "creature" && aged {
+    if (m.kind.category == "creature" || m.species() == crate::mobs::Species::Hoglin) && aged {
         map.insert("Age".into(), Tag::Int(m.extra.age));
         map.insert("AgeLocked".into(), Tag::Byte(i8::from(m.extra.age_locked)));
         map.insert("ForcedAge".into(), Tag::Int(m.extra.forced_age));
@@ -225,7 +269,51 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
     if is_animal(id) {
         map.insert("InLove".into(), Tag::Int(m.extra.in_love.max(0)));
     }
+    let species = m.species();
+    if let Some((_, variant)) =
+        crate::mobs::finalize::species_variant_component(species, m.extra.variant)
+    {
+        map.insert("variant".into(), string(&variant));
+    }
+    if species == crate::mobs::Species::Chicken {
+        map.insert("EggLayTime".into(), Tag::Int(m.extra.egg_time));
+    }
+    let sounds = crate::mobs::finalize::sound_variants(species);
+    if !sounds.is_empty() {
+        let sound = m.extra.sound_variant.and_then(|i| sounds.get(i as usize));
+        let sound = sound.copied().unwrap_or("classic");
+        map.insert(
+            "sound_variant".into(),
+            string(&format!("minecraft:{sound}")),
+        );
+    }
     match id {
+        // Fox.addAdditionalSaveData; Horizon models only the type.
+        "minecraft:fox" => {
+            let kind = if m.extra.variant == 1 { "snow" } else { "red" };
+            map.insert("Type".into(), string(kind));
+            for (key, value) in [
+                ("Trusted", Tag::List(Vec::new())),
+                ("Sleeping", Tag::Byte(0)),
+                ("Sitting", Tag::Byte(0)),
+                ("Crouching", Tag::Byte(0)),
+            ] {
+                map.entry(key.into()).or_insert(value);
+            }
+        }
+        "minecraft:rabbit" => {
+            map.insert("RabbitType".into(), Tag::Int(i32::from(m.extra.variant)));
+            map.entry("MoreCarrotTicks".into()).or_insert(Tag::Int(0));
+        }
+        "minecraft:goat" => {
+            map.insert(
+                "IsScreamingGoat".into(),
+                Tag::Byte(i8::from(m.extra.screaming)),
+            );
+            let [left, right] = m.extra.lost_horns;
+            map.insert("HasLeftHorn".into(), Tag::Byte(i8::from(!left)));
+            map.insert("HasRightHorn".into(), Tag::Byte(i8::from(!right)));
+        }
         "minecraft:creeper" => {
             for (key, value) in [("Fuse", Tag::Short(30)), ("ExplosionRadius", Tag::Byte(3))] {
                 map.entry(key.into()).or_insert(value);
@@ -241,10 +329,6 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             }
             map.insert("Sitting".into(), Tag::Byte(i8::from(m.extra.sitting)));
             map.insert("CollarColor".into(), Tag::Byte(m.extra.color as i8));
-            let variant = crate::mobs::tame::CAT_VARIANTS[(m.extra.variant as usize).min(10)];
-            map.insert("variant".into(), string(&format!("minecraft:{variant}")));
-            map.entry("sound_variant".into())
-                .or_insert_with(|| string("minecraft:classic"));
         }
         "minecraft:wolf" => {
             if let Some(owner) = m.extra.owner {
@@ -254,17 +338,30 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             }
             map.insert("Sitting".into(), Tag::Byte(i8::from(m.extra.sitting)));
             map.insert("CollarColor".into(), Tag::Byte(m.extra.color as i8));
-            let variant = crate::mobs::tame::WOLF_VARIANTS[(m.extra.variant as usize).min(8)].0;
-            map.insert("variant".into(), string(&format!("minecraft:{variant}")));
-            map.entry("sound_variant".into())
-                .or_insert_with(|| string("minecraft:classic"));
         }
         "minecraft:piglin" | "minecraft:piglin_brute" | "minecraft:hoglin" => {
+            // Only Piglin.addAdditionalSaveData writes CannotHunt.
+            if id == "minecraft:piglin_brute" {
+                map.remove(&"CannotHunt".into());
+            }
             map.insert(
                 "IsImmuneToZombification".into(),
                 Tag::Byte(i8::from(m.extra.flag2)),
             );
             map.insert("TimeInOverworld".into(), Tag::Int(m.extra.counter2));
+            if id == "minecraft:piglin" {
+                // InventoryCarrier.writeInventoryToTag.
+                map.insert(
+                    "Inventory".into(),
+                    Tag::List(
+                        m.extra
+                            .inventory
+                            .iter()
+                            .map(crate::save::item_to_nbt)
+                            .collect(),
+                    ),
+                );
+            }
         }
         "minecraft:horse"
         | "minecraft:donkey"
@@ -275,6 +372,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         | "minecraft:trader_llama" => {
             map.insert("Tame".into(), Tag::Byte(i8::from(m.extra.tame)));
             map.insert("Temper".into(), Tag::Int(i32::from(m.extra.variant3)));
+            // AbstractHorse.addAdditionalSaveData; Horizon models neither.
+            for key in ["EatingHaystack", "Bred"] {
+                map.entry(key.into()).or_insert(Tag::Byte(0));
+            }
             if let Some(owner) = m.extra.owner {
                 map.insert("Owner".into(), Tag::IntArray(owner.to_vec()));
             }
@@ -357,6 +458,12 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         "minecraft:bat" => {
             map.insert("BatFlags".into(), Tag::Byte(i8::from(m.extra.flag)));
         }
+        "minecraft:turtle" => {
+            map.insert("has_egg".into(), Tag::Byte(i8::from(m.extra.flag)));
+            if let Some(home) = m.extra.home {
+                map.insert("home_pos".into(), Tag::IntArray(home.to_vec()));
+            }
+        }
         "minecraft:creaking" => {
             // home_pos: the heart it is bound to.
             if let Some(home) = m.extra.home {
@@ -384,7 +491,32 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
             crate::mobs::villager::write_nbt(m, map);
         }
         "minecraft:wandering_trader" => put_offers(map, m),
-        "minecraft:axolotl" => write_axolotl_memories(m, map),
+        "minecraft:axolotl" => {
+            write_axolotl_memories(m, map);
+            map.insert(
+                "Variant".into(),
+                Tag::Int(i32::from(m.extra.variant.min(4))),
+            );
+        }
+        "minecraft:parrot" => {
+            map.insert(
+                "Variant".into(),
+                Tag::Int(i32::from(m.extra.variant.min(4))),
+            );
+        }
+        "minecraft:salmon" => {
+            let size = SALMON_SIZES[usize::from(m.extra.variant).min(2)];
+            map.insert("type".into(), string(size));
+        }
+        // TropicalFish.addAdditionalSaveData: the packed variant.
+        "minecraft:tropical_fish" => {
+            let pattern = m.extra.variant.min(11);
+            let packed = i32::from(pattern >= 6)
+                | i32::from(pattern % 6) << 8
+                | i32::from(m.extra.variant2 & 15) << 16
+                | i32::from(m.extra.variant3 & 15) << 24;
+            map.insert("Variant".into(), Tag::Int(packed));
+        }
         "minecraft:allay" => {
             // InventoryCarrier: the fetched stack; the liked player memory.
             let mut inv = Vec::new();
@@ -445,6 +577,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
                 map.insert("anger".into(), Tag::compound(Vec::<(&str, Tag)>::new()));
             }
         }
+        // Armadillo.addAdditionalSaveData: the time left to the next scute.
+        "minecraft:armadillo" => {
+            map.insert("scute_time".into(), Tag::Int(m.extra.egg_time));
+        }
         "minecraft:ravager" => {
             map.insert("AttackTick".into(), Tag::Int(m.extra.counter));
             map.insert("StunTick".into(), Tag::Int(m.extra.counter2));
@@ -479,10 +615,8 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
                 )])
             });
         }
-        "minecraft:zombie" => {
-            map.insert("IsBaby".into(), Tag::Byte(i8::from(m.is_baby())));
+        "minecraft:zombie" | "minecraft:husk" | "minecraft:drowned" => {
             for (key, value) in [
-                ("CanBreakDoors", Tag::Byte(0)),
                 ("DrownedConversionTime", Tag::Int(-1)),
                 ("InWaterTime", Tag::Int(-1)),
             ] {
@@ -507,6 +641,28 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
         }
         _ => {}
     }
+    // Zombie.addAdditionalSaveData: CanBreakDoors.
+    if crate::mobs::doors::is_zombie(m.species()) {
+        map.insert(
+            "CanBreakDoors".into(),
+            Tag::Byte(i8::from(m.extra.can_break_doors)),
+        );
+    }
+    if matches!(
+        id,
+        "minecraft:zombie"
+            | "minecraft:husk"
+            | "minecraft:drowned"
+            | "minecraft:zombie_villager"
+            | "minecraft:zombified_piglin"
+            | "minecraft:piglin"
+            | "minecraft:zoglin"
+    ) {
+        map.insert("IsBaby".into(), Tag::Byte(i8::from(m.is_baby())));
+    }
+    if let Some(a) = m.extra.attributes.as_deref() {
+        put_attributes(map, m, a);
+    }
     crate::mobs::raider::write_nbt(m, map);
     crate::mobs::riders::write_nbt(m, map);
     // LivingEntity equipment: what the mob holds now.
@@ -589,6 +745,89 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
     }
     tag
 }
+/// `AttributeMap.pack` for the attributes with a base or permanent modifier
+/// finalizeSpawn set, over the saved list.
+fn put_attributes(map: &mut Compound, m: &Mob, a: &crate::mobs::finalize::Attributes) {
+    use crate::mobs::finalize::{self, Attr, Op};
+    let mut list = match map.get(&"attributes".into()) {
+        Some(Tag::List(l)) => l.clone(),
+        _ => Vec::new(),
+    };
+    for attr in Attr::ALL {
+        let modifiers: Vec<Tag> = a
+            .modifiers
+            .iter()
+            .filter(|x| x.attr == attr)
+            .map(|x| {
+                let op = match x.op {
+                    Op::AddValue => "add_value",
+                    Op::AddMultipliedBase => "add_multiplied_base",
+                    Op::AddMultipliedTotal => "add_multiplied_total",
+                };
+                Tag::compound([
+                    ("id", string(x.id)),
+                    ("amount", Tag::Double(x.amount.to_bits())),
+                    ("operation", string(op)),
+                ])
+            })
+            .collect();
+        if modifiers.is_empty() && !a.bases.iter().any(|(b, _)| *b == attr) {
+            continue;
+        }
+        let id = format!("minecraft:{}", attr.name());
+        let mut entry = vec![
+            ("id", string(&id)),
+            ("base", Tag::Double(finalize::base_value(m, attr).to_bits())),
+        ];
+        if !modifiers.is_empty() {
+            entry.push(("modifiers", Tag::List(modifiers)));
+        }
+        let entry = Tag::compound(entry);
+        match list
+            .iter_mut()
+            .find(|t| text(t.get("id")).as_deref() == Some(id.as_str()))
+        {
+            Some(t) => *t = entry,
+            None => list.push(entry),
+        }
+    }
+    map.insert("attributes".into(), Tag::List(list));
+}
+/// `Brain.Packed`: the memories finalizeSpawn set, over the saved ones.
+pub fn put_brain(map: &mut Compound, m: &Mob, dimension: &str) {
+    if m.extra.memories.is_empty() {
+        return;
+    }
+    let mut memories = match map.get(&"Brain".into()).and_then(|b| b.get("memories")) {
+        Some(Tag::Compound(c)) => c.clone(),
+        _ => Compound::new(),
+    };
+    for &(name, value, ttl) in &m.extra.memories {
+        let value = match name {
+            "hunted_recently" => Tag::Byte(value as i8),
+            "home" => match m.extra.home {
+                Some(p) => Tag::compound([
+                    ("dimension", string(dimension)),
+                    ("pos", Tag::IntArray(p.to_vec())),
+                ]),
+                None => continue,
+            },
+            _ => Tag::Int(value as i32),
+        };
+        let mut memory = vec![("value", value)];
+        if ttl != i64::MAX {
+            memory.push(("ttl", Tag::Long(ttl)));
+        }
+        memories.insert(
+            format!("minecraft:{name}").as_str().into(),
+            Tag::compound(memory),
+        );
+    }
+    map.insert(
+        "Brain".into(),
+        Tag::compound([("memories", Tag::Compound(memories))]),
+    );
+}
 /// `CustomName`: a text component saved as a string or a `{text: ..}` compound.
 fn custom_name(tag: &Tag) -> Option<String> {
     match tag.get("CustomName")? {
@@ -608,6 +847,22 @@ pub fn name_text(tag: &Tag) -> Text {
         t => crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(t)),
     }
 }
+/// Mob.finalizeSpawn's follow range bonus in the saved attributes.
+pub(crate) fn spawn_bonus(tag: &Tag) -> Option<f64> {
+    let Some(Tag::List(attrs)) = tag.get("attributes") else {
+        return None;
+    };
+    let range = attrs
+        .iter()
+        .find(|a| text(a.get("id")).as_deref() == Some("minecraft:follow_range"))?;
+    let Some(Tag::List(modifiers)) = range.get("modifiers") else {
+        return None;
+    };
+    let bonus = modifiers
+        .iter()
+        .find(|x| text(x.get("id")).as_deref() == Some("minecraft:random_spawn_bonus"))?;
+    float(bonus.get("amount"))
+}
 pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -> Option<Mob> {
     let kind = types.get(&self::kind(tag)?)?.clone();
     let position = position(tag)?;
@@ -633,7 +888,18 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
             }
         }
     }
+    if let Some(bonus) = spawn_bonus(tag) {
+        use crate::mobs::finalize::{Attr, Op, add_modifier};
+        let id = "minecraft:random_spawn_bonus";
+        add_modifier(&mut m, Attr::FollowRange, id, bonus, Op::AddMultipliedBase);
+    }
     m.health = float(tag.get("Health")).map_or(m.attrs.max_health, |h| h as f32);
+    // LivingEntity.setHealth clamps to the max health: a horse or llama is made
+    // with the type's and saved before it drops to the one it rolled. (Only
+    // the base is read here, so the clamp would cut a leader zombie's bonus.)
+    if crate::mobs::equine::is_equine(m.species()) {
+        m.health = m.health.min(m.attrs.max_health);
+    }
     m.hurt_time = number(tag.get("HurtTime")).unwrap_or(0) as i32;
     // What it holds (equipment.mainhand / offhand), when saved.
     if let Some(eq) = tag.get("equipment") {
@@ -674,7 +940,8 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     m.extra.pick_up_loot = flag(tag, "CanPickUpLoot");
     m.custom_name = custom_name(tag);
     m.custom_name_text = tag.get("CustomName").map(name_text);
-    if m.kind.category == "creature" {
+    m.extra.left_handed = flag(tag, "LeftHanded");
+    if m.kind.category == "creature" || m.species() == crate::mobs::Species::Hoglin {
         m.extra.age = number(tag.get("Age")).unwrap_or(0) as i32;
         m.extra.forced_age = number(tag.get("ForcedAge")).unwrap_or(0) as i32;
         m.extra.age_locked = flag(tag, "AgeLocked");
@@ -687,6 +954,25 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     m.no_gravity = flag(tag, "NoGravity");
     m.glowing = flag(tag, "Glowing");
     m.ticks_frozen = number(tag.get("TicksFrozen")).unwrap_or(0) as i32;
+    // LivingEntity.readAdditionalSaveData: the saved `active_effects`, the last
+    // entry of an effect winning.
+    if let Some(Tag::List(effects)) = tag.get("active_effects") {
+        for e in effects {
+            let Some(def) = text(e.get("id")).and_then(|id| crate::brewing::effect(&id)) else {
+                continue;
+            };
+            let effect = crate::brewing::namespaced(def.id);
+            let duration = number(e.get("duration")).unwrap_or(0) as i32;
+            let amplifier = number(e.get("amplifier")).unwrap_or(0) as i32;
+            m.extra.effects.retain(|x| x.0 != effect);
+            m.extra.effects.push((effect, duration, amplifier));
+            // Details.CODEC: `show_particles` defaults to true.
+            m.extra.hidden_effects.retain(|h| *h != effect);
+            if number(e.get("show_particles")) == Some(0) {
+                m.extra.hidden_effects.push(effect);
+            }
+        }
+    }
     m.silent = flag(tag, "Silent");
     m.invulnerable_flag = flag(tag, "Invulnerable");
     if m.species() == crate::mobs::Species::Bat {
@@ -706,6 +992,16 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     ) {
         m.extra.flag2 = flag(tag, "IsImmuneToZombification");
         m.extra.counter2 = number(tag.get("TimeInOverworld")).unwrap_or(0) as i32;
+        if m.species() == crate::mobs::Species::Piglin
+            && let Some(Tag::List(items)) = tag.get("Inventory")
+        {
+            // InventoryCarrier.readInventoryFromTag (eight slots).
+            m.extra.inventory = items
+                .iter()
+                .filter_map(crate::save::item_from_nbt)
+                .take(8)
+                .collect();
+        }
     }
     if matches!(
         m.species(),
@@ -758,20 +1054,45 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
             m.extra.vector[0] = 0.7;
         }
     }
+    if crate::mobs::finalize::species_variant_component(m.species(), 0).is_some()
+        && let Some(v) = text(tag.get("variant"))
+    {
+        m.extra.variant = crate::mobs::finalize::variant_index(m.species(), &v);
+    }
+    if m.species() == crate::mobs::Species::Chicken
+        && let Some(t) = number(tag.get("EggLayTime"))
+    {
+        m.extra.egg_time = t as i32;
+    }
+    if let Some(v) = text(tag.get("sound_variant")) {
+        let v = v.trim_start_matches("minecraft:");
+        let sounds = crate::mobs::finalize::sound_variants(m.species());
+        m.extra.sound_variant = sounds.iter().position(|n| *n == v).map(|i| i as u8);
+    }
+    match m.species() {
+        crate::mobs::Species::Fox => {
+            m.extra.variant = u8::from(text(tag.get("Type")).as_deref() == Some("snow"));
+        }
+        crate::mobs::Species::Rabbit => {
+            // Rabbit.Variant.byId: an unknown id is brown.
+            m.extra.variant = match number(tag.get("RabbitType")).unwrap_or(0) {
+                v @ (0..=5 | 99) => v as u8,
+                _ => 0,
+            };
+        }
+        crate::mobs::Species::Goat => {
+            m.extra.screaming = flag(tag, "IsScreamingGoat");
+            let horn = |key| number(tag.get(key)).is_some_and(|v| v == 0);
+            m.extra.lost_horns = [horn("HasLeftHorn"), horn("HasRightHorn")];
+        }
+        _ => {}
+    }
     if m.species() == crate::mobs::Species::Cat {
         m.extra.owner = crate::save::uuid_from_tag(tag.get("Owner"));
         m.extra.tame = m.extra.owner.is_some();
         m.extra.sitting = flag(tag, "Sitting");
         m.extra.color =
             number(tag.get("CollarColor")).map_or(crate::mobs::tame::RED, |c| (c as u8) & 15);
-        if let Some(Tag::String(v)) = tag.get("variant") {
-            let v = v.to_string().unwrap_or_default();
-            let v = v.trim_start_matches("minecraft:");
-            m.extra.variant = crate::mobs::tame::CAT_VARIANTS
-                .iter()
-                .position(|n| *n == v)
-                .unwrap_or(0) as u8;
-        }
     }
     if m.species() == crate::mobs::Species::Wolf {
         let health = m.health;
@@ -782,14 +1103,6 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
         m.extra.sitting = flag(tag, "Sitting");
         m.extra.color =
             number(tag.get("CollarColor")).map_or(crate::mobs::tame::RED, |c| (c as u8) & 15);
-        if let Some(Tag::String(v)) = tag.get("variant") {
-            let v = v.to_string().unwrap_or_default();
-            let v = v.trim_start_matches("minecraft:");
-            m.extra.variant = crate::mobs::tame::WOLF_VARIANTS
-                .iter()
-                .position(|(n, _)| *n == v)
-                .unwrap_or(0) as u8;
-        }
     }
     if matches!(
         m.species(),
@@ -808,6 +1121,7 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     if m.species() == crate::mobs::Species::Axolotl {
         restore_axolotl_memories(&mut m, tag);
     }
+    read_variant(&mut m, tag);
     m.fire_ticks = number(tag.get("Fire")).unwrap_or(0) as i32;
     m.air = number(tag.get("Air")).unwrap_or(300) as i32;
     if m.species() == crate::mobs::Species::Allay {
@@ -847,6 +1161,18 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     {
         crate::mobs::creaking::set_transient(&mut m, [home[0], home[1], home[2]]);
     }
+    if m.species() == crate::mobs::Species::Turtle {
+        // Turtle.readAdditionalSaveData: `home_pos` (else where it stands) and `has_egg`.
+        m.extra.flag = flag(tag, "has_egg");
+        m.extra.home = Some(match tag.get("home_pos") {
+            Some(Tag::IntArray(home)) if home.len() == 3 => [home[0], home[1], home[2]],
+            _ => [
+                m.position.x.floor() as i32,
+                m.position.y.floor() as i32,
+                m.position.z.floor() as i32,
+            ],
+        });
+    }
     if m.species() == crate::mobs::Species::Wither {
         m.extra.counter = number(tag.get("Invul")).unwrap_or(0) as i32;
     }
@@ -876,6 +1202,12 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
             st.vibration = crate::sculk::Data::from_nbt(listener);
         }
     }
+    // Armadillo.readAdditionalSaveData: keeps the constructor's time when absent.
+    if m.species() == crate::mobs::Species::Armadillo
+        && let Some(t) = number(tag.get("scute_time"))
+    {
+        m.extra.egg_time = t as i32;
+    }
     if m.species() == crate::mobs::Species::Ravager {
         m.extra.counter = number(tag.get("AttackTick")).unwrap_or(0) as i32;
         m.extra.counter2 = number(tag.get("StunTick")).unwrap_or(0) as i32;
@@ -925,6 +1257,10 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
     if !crate::mobs::finalize::ageable(m.species()) && flag(tag, "IsBaby") {
         crate::mobs::finalize::set_baby(&mut m, true);
     }
+    // Zombie.readAdditionalSaveData: setCanBreakDoors.
+    if crate::mobs::doors::is_zombie(m.species()) {
+        crate::mobs::doors::set_can_break_doors(&mut m, flag(tag, "CanBreakDoors"));
+    }
     crate::mobs::raider::read_nbt(&mut m, tag);
     crate::mobs::riders::read_nbt(&mut m, tag);
     // A mob saved mid-death finishes dying; one saved dead is dropped.
@@ -1043,18 +1379,18 @@ pub fn orb_to_nbt(o: &ExperienceOrb, uuid: [i32; 4]) -> Tag {
         ("Health", Tag::Short(5)),
         ("Age", Tag::Short(o.age.min(i16::MAX as u32) as i16)),
         ("Value", Tag::Short(o.value.min(i16::MAX as u32) as i16)),
-        ("Count", Tag::Int(1)),
+        ("Count", Tag::Int(o.count.min(i32::MAX as u32) as i32)),
     ] {
         put(&mut tag, key, value);
     }
     tag
 }
-/// One Horizon orb per counted orb (vanilla merges orbs of equal value).
+/// One orb with its merged `Count`.
 pub fn orbs_from_nbt(tag: &Tag) -> Vec<ExperienceOrb> {
     let Some(position) = position(tag) else {
         return Vec::new();
     };
-    let count = number(tag.get("Count")).unwrap_or(1).clamp(1, 64) as usize;
+    let count = number(tag.get("Count")).unwrap_or(1).max(1) as u32;
     let orb = ExperienceOrb {
         id: 0,
         position,
@@ -1063,8 +1399,10 @@ pub fn orbs_from_nbt(tag: &Tag) -> Vec<ExperienceOrb> {
         value: number(tag.get("Value")).unwrap_or(1).max(1) as u32,
         age: number(tag.get("Age")).unwrap_or(0).max(0) as u32,
         on_ground: flag(tag, "OnGround"),
+        count,
+        ticks: 0,
     };
-    vec![orb; count]
+    vec![orb]
 }
 
 /// `Projectile` + `AbstractArrow.addAdditionalSaveData` of a live arrow;
@@ -1913,7 +2251,7 @@ mod tests {
         assert_eq!(number(tag.get("Health")), Some(5));
     }
     #[test]
-    fn orbs_expand_their_count() {
+    fn orbs_keep_their_count() {
         let o = ExperienceOrb {
             id: 0,
             position: Vec3::new(1.0, 2.0, 3.0),
@@ -1922,12 +2260,14 @@ mod tests {
             value: 7,
             age: 3,
             on_ground: false,
+            count: 3,
+            ticks: 0,
         };
-        let mut tag = orb_to_nbt(&o, [0; 4]);
-        put(&mut tag, "Count", Tag::Int(3));
+        let tag = orb_to_nbt(&o, [0; 4]);
         let back = orbs_from_nbt(&tag);
-        assert_eq!(back.len(), 3);
+        assert_eq!(back.len(), 1);
         assert_eq!(back[0].value, 7);
+        assert_eq!(back[0].count, 3);
     }
 }
 
@@ -1969,6 +2309,41 @@ fn write_axolotl_memories(m: &Mob, map: &mut Compound) {
         }
     }
 }
+/// The variant tags `Axolotl`, `Rabbit`, `Parrot`, `Salmon` and
+/// `TropicalFish` read; a missing tag is the default variant (a medium
+/// salmon, otherwise index 0).
+fn read_variant(m: &mut Mob, tag: &Tag) {
+    use crate::mobs::Species as S;
+    let int = |key| number(tag.get(key)).unwrap_or(0) as i32;
+    match m.species() {
+        S::Axolotl | S::Parrot => m.extra.variant = int("Variant").clamp(0, 4) as u8,
+        // Rabbit.Variant.LEGACY_CODEC: an unknown id is brown.
+        S::Rabbit => {
+            m.extra.variant = match int("RabbitType") {
+                v @ (0..=5 | 99) => v as u8,
+                _ => 0,
+            }
+        }
+        S::Salmon => {
+            m.extra.variant = text(tag.get("type"))
+                .and_then(|t| SALMON_SIZES.iter().position(|v| *v == t))
+                .unwrap_or(1) as u8;
+        }
+        S::TropicalFish => {
+            let packed = int("Variant");
+            let (size, index) = (packed & 0xFF, (packed >> 8) & 0xFF);
+            // TropicalFish.Pattern.byId: an unknown id is a kob.
+            m.extra.variant = if size <= 1 && index < 6 {
+                (size * 6 + index) as u8
+            } else {
+                0
+            };
+            m.extra.variant2 = ((packed >> 16) & 15) as u8;
+            m.extra.variant3 = ((packed >> 24) & 15) as u8;
+        }
+        _ => {}
+    }
+}
 fn restore_axolotl_memories(m: &mut Mob, tag: &Tag) {
     let memories = tag.get("Brain").and_then(|b| b.get("memories"));
     let ttl = memories
@@ -1992,12 +2367,39 @@ fn restore_axolotl_memories(m: &mut Mob, tag: &Tag) {
     }
 }
 const AXOLOTL_VARIANTS: [&str; 5] = ["lucy", "wild", "gold", "cyan", "blue"];
+/// `Salmon.Variant` names, by id.
+const SALMON_SIZES: [&str; 3] = ["small", "medium", "large"];
+/// `TropicalFish.Pattern` names in enum order: the six small patterns, then
+/// the six large ones (the order of `extra.variant`).
+const TROPICAL_PATTERNS: [&str; 12] = [
+    "kob",
+    "sunstreak",
+    "snooper",
+    "dasher",
+    "brinely",
+    "spotty",
+    "flopper",
+    "stripey",
+    "glitter",
+    "blockfish",
+    "betty",
+    "clayfish",
+];
+/// `Bucketable.saveDefaultDataToBucketTag`, with the age an axolotl and a
+/// tadpole add (`saveToBucketTag`).
 pub fn bucket_data(m: &Mob) -> Tag {
-    let mut data = Tag::compound([
-        ("Age", Tag::Int(m.extra.age)),
-        ("AgeLocked", Tag::Byte(i8::from(m.extra.age_locked))),
-        ("Health", Tag::Float(m.health.to_bits())),
-    ]);
+    let mut data = Tag::compound([("Health", Tag::Float(m.health.to_bits()))]);
+    if matches!(
+        m.species(),
+        crate::mobs::Species::Axolotl | crate::mobs::Species::Tadpole
+    ) {
+        put(&mut data, "Age", Tag::Int(m.extra.age));
+        put(
+            &mut data,
+            "AgeLocked",
+            Tag::Byte(i8::from(m.extra.age_locked)),
+        );
+    }
     for (key, on) in [
         ("NoAI", m.no_ai),
         ("Silent", m.silent),
@@ -2027,6 +2429,29 @@ pub fn bucket_components(m: &Mob) -> crate::item_data::StackData {
             .unwrap_or(&"lucy");
         data.set_other("minecraft:axolotl/variant", Some(string(variant)));
     }
+    // Salmon.saveToBucketTag: the size.
+    if m.species() == crate::mobs::Species::Salmon {
+        let size = SALMON_SIZES
+            .get(usize::from(m.extra.variant))
+            .unwrap_or(&"medium");
+        data.set_other("minecraft:salmon/size", Some(string(size)));
+    }
+    // TropicalFish.saveToBucketTag: the pattern and both colours.
+    if m.species() == crate::mobs::Species::TropicalFish {
+        let dye = |i: u8| crate::mobs::render::DYE_NAMES[usize::from(i) & 15];
+        let pattern = TROPICAL_PATTERNS
+            .get(usize::from(m.extra.variant))
+            .unwrap_or(&"kob");
+        data.set_other("minecraft:tropical_fish/pattern", Some(string(pattern)));
+        data.set_other(
+            "minecraft:tropical_fish/base_color",
+            Some(string(dye(m.extra.variant2))),
+        );
+        data.set_other(
+            "minecraft:tropical_fish/pattern_color",
+            Some(string(dye(m.extra.variant3))),
+        );
+    }
     data
 }
 pub fn load_bucket_data(m: &mut Mob, stack: &crate::items::ItemStack) {
@@ -2077,6 +2502,39 @@ pub fn load_bucket_data(m: &mut Mob, stack: &crate::items::ItemStack) {
     {
         m.extra.variant = id as u8;
     }
+    // Salmon.applyImplicitComponents: the size.
+    if m.species() == crate::mobs::Species::Salmon
+        && let Some(name) = text(components.other("minecraft:salmon/size"))
+        && let Some(id) = SALMON_SIZES
+            .iter()
+            .position(|&v| v == name.trim_start_matches("minecraft:"))
+    {
+        m.extra.variant = id as u8;
+    }
+    // TropicalFish.applyImplicitComponent: the pattern and both colours.
+    if m.species() == crate::mobs::Species::TropicalFish {
+        let name = |key| text(components.other(key));
+        let dye = |key| {
+            name(key).and_then(|n| {
+                crate::mobs::render::DYE_NAMES
+                    .iter()
+                    .position(|&v| v == n.trim_start_matches("minecraft:"))
+            })
+        };
+        if let Some(id) = name("minecraft:tropical_fish/pattern").and_then(|n| {
+            TROPICAL_PATTERNS
+                .iter()
+                .position(|&v| v == n.trim_start_matches("minecraft:"))
+        }) {
+            m.extra.variant = id as u8;
+        }
+        if let Some(id) = dye("minecraft:tropical_fish/base_color") {
+            m.extra.variant2 = id as u8;
+        }
+        if let Some(id) = dye("minecraft:tropical_fish/pattern_color") {
+            m.extra.variant3 = id as u8;
+        }
+    }
 }
 
 #[cfg(test)]
@@ -2287,6 +2745,123 @@ mod sheep_nbt_tests {
         let back = mob_from_nbt(&tag, &types, 2).unwrap();
         assert_eq!((back.extra.color, back.extra.sheared), (14, true));
     }
+
+    #[test]
+    fn farm_animals_keep_their_variant_and_sound_variant() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("items.json").exists() {
+            return;
+        }
+        let data = crate::mobs::MobTypes::load(&root).unwrap();
+        let types: HashMap<String, Arc<MobType>> = data
+            .types
+            .iter()
+            .map(|(k, v)| (k.clone(), Arc::new(v.clone())))
+            .collect();
+        let mut m = Mob::new(
+            1,
+            types["minecraft:pig"].clone(),
+            Vec3::new(0.0, 4.0, 0.0),
+            0.0,
+        );
+        let tag = mob_to_nbt(&m, [1, 2, 3, 4], None);
+        assert_eq!(
+            text(tag.get("variant")).as_deref(),
+            Some("minecraft:temperate")
+        );
+        assert_eq!(
+            text(tag.get("sound_variant")).as_deref(),
+            Some("minecraft:classic")
+        );
+        // Spawned in a warm biome with the mini sounds.
+        (m.extra.variant, m.extra.sound_variant) = (1, Some(2));
+        let tag = mob_to_nbt(&m, [1, 2, 3, 4], None);
+        assert_eq!(text(tag.get("variant")).as_deref(), Some("minecraft:warm"));
+        assert_eq!(
+            text(tag.get("sound_variant")).as_deref(),
+            Some("minecraft:mini")
+        );
+        let back = mob_from_nbt(&tag, &types, 2).unwrap();
+        assert_eq!((back.extra.variant, back.extra.sound_variant), (1, Some(2)));
+        let mut hen = Mob::new(
+            3,
+            types["minecraft:chicken"].clone(),
+            Vec3::new(0.0, 4.0, 0.0),
+            0.0,
+        );
+        (hen.extra.variant, hen.extra.egg_time) = (2, 7795);
+        let tag = mob_to_nbt(&hen, [1, 2, 3, 4], None);
+        assert_eq!(text(tag.get("variant")).as_deref(), Some("minecraft:cold"));
+        let back = mob_from_nbt(&tag, &types, 4).unwrap();
+        assert_eq!((back.extra.variant, back.extra.egg_time), (2, 7795));
+        // The sound variants are indices into the registries finalizeSpawn draws from.
+        use crate::mobs::{Species, finalize};
+        let registries = finalize::SpawnRegistries::load(&root);
+        for (species, registry) in [
+            (Species::Pig, &registries.pig_sound),
+            (Species::Cow, &registries.cow_sound),
+            (Species::Chicken, &registries.chicken_sound),
+            (Species::Cat, &registries.cat_sound),
+            (Species::Wolf, &registries.wolf_sound),
+        ] {
+            assert_eq!(
+                finalize::sound_variants(species),
+                registry.names,
+                "{species:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn foxes_rabbits_and_goats_keep_their_kind() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("items.json").exists() {
+            return;
+        }
+        let data = crate::mobs::MobTypes::load(&root).unwrap();
+        let types: HashMap<String, Arc<MobType>> = data
+            .types
+            .iter()
+            .map(|(k, v)| (k.clone(), Arc::new(v.clone())))
+            .collect();
+        let new = |kind: &str| Mob::new(1, types[kind].clone(), Vec3::new(0.0, 4.0, 0.0), 0.0);
+        let round_trip = |m: &Mob| {
+            let tag = mob_to_nbt(m, [1, 2, 3, 4], None);
+            (mob_from_nbt(&tag, &types, 2).unwrap(), tag)
+        };
+        let mut fox = new("minecraft:fox");
+        fox.extra.variant = 1;
+        let (back, tag) = round_trip(&fox);
+        assert_eq!(text(tag.get("Type")).as_deref(), Some("snow"));
+        assert_eq!(number(tag.get("Sleeping")), Some(0));
+        assert_eq!(back.extra.variant, 1);
+        let mut rabbit = new("minecraft:rabbit");
+        rabbit.extra.variant = 4;
+        let (back, tag) = round_trip(&rabbit);
+        assert_eq!(number(tag.get("RabbitType")), Some(4));
+        assert_eq!(back.extra.variant, 4);
+        let mut goat = new("minecraft:goat");
+        (goat.extra.screaming, goat.extra.lost_horns) = (true, [false, true]);
+        let (back, tag) = round_trip(&goat);
+        assert_eq!(number(tag.get("HasRightHorn")), Some(0));
+        assert_eq!(
+            (back.extra.screaming, back.extra.lost_horns),
+            (true, [false, true])
+        );
+        // A goat saved without horn flags has both, as vanilla reads it.
+        let bare = Tag::compound([
+            ("id", string("minecraft:goat")),
+            ("Pos", doubles(&[0.5, 64.0, 0.5])),
+        ]);
+        assert_eq!(
+            mob_from_nbt(&bare, &types, 3).unwrap().extra.lost_horns,
+            [false; 2]
+        );
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/horizon-client/src/falling_block.rs b/crates/horizon-client/src/falling_block.rs
index 79ca28f7a..4faf105b9 100644
--- a/crates/horizon-client/src/falling_block.rs
+++ b/crates/horizon-client/src/falling_block.rs
@@ -35,6 +35,18 @@ impl Damage {
             ..Self::default()
         }
     }
+    /// A block that starts to fall: anvils hurt, and a brushable block
+    /// breaks where it lands (BrushableBlock.tick: disableDrop).
+    pub fn falling(block: &str) -> Self {
+        if block.ends_with("anvil") {
+            Self::anvil()
+        } else {
+            Self {
+                cancel_drop: block.starts_with("minecraft:suspicious_"),
+                ..Self::default()
+            }
+        }
+    }
     pub fn from_nbt(tag: &Tag, anvil: bool) -> Self {
         Self {
             hurt_entities: number(tag.get("HurtEntities")).map_or(anvil, |v| v != 0),
@@ -181,6 +193,14 @@ pub fn hurt_mobs(mobs: &mut [Mob], position: Vec3, amount: f32) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    #[test]
+    fn only_brushable_blocks_break_where_they_land() {
+        assert!(Damage::falling("minecraft:suspicious_gravel").cancel_drop);
+        assert!(Damage::falling("minecraft:suspicious_sand").cancel_drop);
+        assert!(!Damage::falling("minecraft:gravel").cancel_drop);
+        assert!(Damage::falling("minecraft:chipped_anvil").hurt_entities);
+    }
+
     #[test]
     fn impact_uses_ceil_distance_capped_damage_and_positive_damage_wear() {
         let damage = Damage::anvil();
diff --git a/crates/horizon-client/src/fire_render.rs b/crates/horizon-client/src/fire_render.rs
index c3a9f6a92..98eff6f9d 100644
--- a/crates/horizon-client/src/fire_render.rs
+++ b/crates/horizon-client/src/fire_render.rs
@@ -48,6 +48,8 @@ pub fn flames(
                 color: 0xffff_ffff,
                 light: 0xf000 | (u32::from(scene_light >> 4) * 16),
                 normal: [0; 4],
+
+                glint_uv: [0.0, 0.0],
             });
         }
         remaining -= 0.45;
diff --git a/crates/horizon-client/src/font.rs b/crates/horizon-client/src/font.rs
index d0e8c8499..2bb712612 100644
--- a/crates/horizon-client/src/font.rs
+++ b/crates/horizon-client/src/font.rs
@@ -889,12 +889,17 @@ impl Font {
         if s.contains('§') {
             return self.width_text(&Text::legacy(s));
         }
-        s.chars().map(|c| self.glyph(c).advance).sum::<f32>().ceil()
+        crate::bidi::visual_str(s)
+            .chars()
+            .map(|c| self.glyph(c).advance)
+            .sum::<f32>()
+            .ceil()
     }
     /// Font.width of a component: `§` codes in the spans are formatting,
-    /// not glyphs.
+    /// not glyphs. Right-to-left text is measured as it is drawn, shaped.
     pub fn width_text(&self, t: &Text) -> f32 {
-        t.resolved()
+        let t = t.resolved();
+        crate::bidi::visual(&t)
             .chars()
             .map(|(c, s)| self.advance(c, s))
             .sum::<f32>()
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 8448f0837..2c3eeed39 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -18,6 +18,7 @@ mod boats;
 mod books;
 mod bossbars;
 mod breezes;
+mod bundles;
 mod campfire;
 mod campfire_douse;
 mod cartography;
@@ -62,9 +63,9 @@ mod frames;
 mod friends;
 mod functions;
 mod game_mode;
-mod game_rules_screen;
 mod gamemode_switcher;
 mod ghasts;
+mod glowing;
 mod golems;
 mod growth;
 mod hand;
@@ -102,7 +103,12 @@ mod maps;
 mod minecarts;
 mod mob_blocks;
 mod mob_gear;
+mod mod_browser;
+#[cfg(feature = "mods")]
+mod mod_browser_recipes;
 mod mod_input;
+#[cfg(feature = "mods")]
+mod mod_recipes;
 mod mod_render;
 mod mods;
 mod mount_menu;
@@ -127,6 +133,7 @@ mod persist;
 mod perspective;
 mod pickups;
 mod piglins;
+mod piston_push;
 mod player_equip;
 mod postprocess;
 mod potions;
@@ -151,6 +158,7 @@ mod scoreboard;
 mod screens;
 mod sculk;
 mod sculk_fixture;
+mod server_links;
 mod server_mods;
 mod server_packs;
 mod server_travel;
@@ -186,6 +194,7 @@ mod win;
 mod wind;
 mod wither;
 mod world_loading;
+mod zombie_reinforcements;
 mod zombie_villagers;
 use horizon_client::{
     Result,
@@ -369,7 +378,7 @@ impl Options {
             match arg.as_str() {
                 "--help" | "-h" => {
                     println!(
-                        "Horizon — Minecraft Java Edition {} in Rust\n\n  --resources PATH        Prepared resources (horizon-prepare)\n  --render-distance N     Chunks, 2..64 (default 12)\n  --world NAME            World folder under saves/ (default \"New World\")\n  --seed N                World seed for new worlds (default 0)\n  --width N, --height N   Window size (default 1280 x 720)\n  --creative              Creative mode (default survival)\n  --test-terrain          Simple test terrain instead of vanilla generation\n  --frames N              Exit after N frames (testing)\n  --world-frames N        Exit after N frames drawn in the world (testing)\n  --smoke-report PATH     Write a JSON report on exit\n  --benchmark SCENARIO    Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n  --control               Accept horizon-ctl commands on a local socket\n  --control-socket PATH   Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n  --server HOST[:PORT]    Join a multiplayer server (offline mode) at start\n  --name NAME             Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n  --session-file PATH     Signed-in account from the launcher (read once, then deleted)\n  --dev-mod PATH          A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n  --in-frame              Run single player's world in the frame, not on its server thread\n  --pregen                Add Horizon's /pregen command (docs/pregeneration.md)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.",
+                        "Horizon — Minecraft Java Edition {} in Rust\n\n  --resources PATH        Prepared resources (horizon-prepare)\n  --render-distance N     Chunks, 2..64 (default 12)\n  --world NAME            World folder under saves/ (default \"New World\")\n  --seed N                World seed for new worlds (default 0)\n  --width N, --height N   Window size (default 1280 x 720)\n  --creative              Creative mode (default survival)\n  --test-terrain          Simple test terrain instead of vanilla generation\n  --frames N              Exit after N frames (testing)\n  --world-frames N        Exit after N frames drawn in the world (testing)\n  --smoke-report PATH     Write a JSON report on exit\n  --benchmark SCENARIO    Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n  --control               Accept horizon-ctl commands on a local socket\n  --control-socket PATH   Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n  --server HOST[:PORT]    Join a multiplayer server (offline mode) at start\n  --quickPlaySingleplayer WORLD  Open this world of saves/ at start, only if it exists (vanilla's)\n  --quickPlayMultiplayer HOST[:PORT]  The same as --server (vanilla's name)\n  --name NAME             Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n  --session-file PATH     Signed-in account from the launcher (read once, then deleted)\n  --dev-mod PATH          A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n  --in-frame              Run single player's world in the frame, not on its server thread\n  --pregen                Add Horizon's /pregen command (docs/pregeneration.md)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.",
                         horizon_core::VANILLA_VERSION
                     );
                     return Ok(None);
@@ -424,6 +433,16 @@ impl Options {
                         "--width" => o.window_size[0] = value.parse::<u32>()?.max(1),
                         "--height" => o.window_size[1] = value.parse::<u32>()?.max(1),
                         "--world" => o.world = Some(value),
+                        // Vanilla's quick play (Main, QuickPlay.joinSingleplayerWorld): only a
+                        // world that exists opens; else the title screen. --world also creates one.
+                        "--quickPlaySingleplayer" => {
+                            let folder = std::env::current_dir()?.join("saves").join(&value);
+                            if folder.join("level.dat").is_file() {
+                                o.world = Some(value);
+                            } else {
+                                eprintln!("Quick play: there is no world {value} in saves/");
+                            }
+                        }
                         "--dev-mod" => o.dev_mods.push(std::path::absolute(&value)?),
                         "--benchmark" => {
                             if horizon_client::benchmark::scenes(&value).is_none() {
@@ -434,7 +453,7 @@ impl Options {
                             }
                             o.benchmark = Some(value);
                         }
-                        "--server" => o.server = Some(value),
+                        "--server" | "--quickPlayMultiplayer" => o.server = Some(value),
                         "--name" => o.player_name = Some(value),
                         "--session-file" => session_file = Some(value),
                         "--control-socket" => o.control = Some(value.into()),
@@ -491,6 +510,12 @@ enum Screen {
     Friends,
     /// CommandBlockEditScreen (game/command_blocks.rs).
     CommandBlock,
+    /// ServerLinksDialogScreen: a server's links (game/server_links.rs).
+    ServerLinks,
+    /// ConfirmLinkScreen for a server link (game/server_links.rs).
+    ConfirmLink,
+    /// DialogScreen.WarningScreen: the note about custom screens.
+    DialogWarning,
     /// WinScreen: the end poem and the credits (game/win.rs).
     Win,
     /// A `ui` mod's own screen, or its settings page from Options > Mods
@@ -537,6 +562,8 @@ struct GameLevel<'w> {
     events: &'w mut Vec<LevelEvent>,
     dimension: LevelDimension,
     darken: i32,
+    /// The environment of the level's dimension (`SUN_ANGLE`).
+    environment: &'w Environment,
     raining: bool,
     thundering: bool,
     player_box: Option<([f64; 3], [f64; 3])>,
@@ -545,6 +572,10 @@ struct GameLevel<'w> {
     player_collision: Option<PlayerCollision>,
     /// Minecart boxes (detector rails).
     cart_boxes: Vec<([f64; 3], [f64; 3])>,
+    /// Each minecart's kind and comparator signal, in `cart_boxes` order.
+    cart_signals: Vec<(minecarts::CartKind, i32)>,
+    /// Arrow and thrown trident boxes (wooden buttons).
+    arrow_boxes: Vec<([f64; 3], [f64; 3])>,
     /// The other entities that keep blocks from being placed into them.
     blockers: Blockers<'w>,
     biomes: &'w Biomes,
@@ -621,6 +652,37 @@ impl EntityObstructionWorld for BuildingObstruction {
     }
 }
 impl GameLevel<'_> {
+    /// `DetectorRailBlock.getAnalogOutputSignal`: a powered rail reads the
+    /// minecart on it, a command block cart first (its success count, which
+    /// is 0 here), else the first container cart's fullness.
+    fn detector_rail_signal(&self, pos: BlockPos, powered: bool) -> i32 {
+        if !powered {
+            return 0;
+        }
+        let (x, y, z) = (f64::from(pos.x), f64::from(pos.y), f64::from(pos.z));
+        let area = Aabb::new(
+            Vec3::new(x + 0.2, y, z + 0.2),
+            Vec3::new(x + 0.8, y + 0.8, z + 0.8),
+        );
+        let mut container = None;
+        for ((lo, hi), &(kind, signal)) in self.cart_boxes.iter().zip(&self.cart_signals) {
+            let cart = Aabb::new(
+                Vec3::new(lo[0], lo[1], lo[2]),
+                Vec3::new(hi[0], hi[1], hi[2]),
+            );
+            if !area.intersects(cart) {
+                continue;
+            }
+            match kind {
+                minecarts::CartKind::CommandBlock => return 0,
+                minecarts::CartKind::Chest | minecarts::CartKind::Hopper => {
+                    container = container.or(Some(signal));
+                }
+                _ => {}
+            }
+        }
+        container.unwrap_or(0)
+    }
     /// Every entity box that blocks building: the players who aren't
     /// spectators, the minecarts and the `Blockers` (a removed mob or a marker
     /// armor stand, whose box is empty, doesn't).
@@ -681,6 +743,14 @@ impl LevelAccess for GameLevel<'_> {
         state: BlockStateId,
         _direction: Direction,
     ) -> i32 {
+        if let Some(s) = self.registry.state(state)
+            && s.name == "minecraft:detector_rail"
+        {
+            return self.detector_rail_signal(
+                pos,
+                s.properties.get("powered").is_some_and(|v| v == "true"),
+            );
+        }
         if let Some(signal) = command_blocks::analog_signal(self.world, (pos.x, pos.y, pos.z)) {
             return signal;
         }
@@ -803,6 +873,11 @@ impl LevelAccess for GameLevel<'_> {
     fn sky_darken(&self) -> i32 {
         self.darken
     }
+    fn sun_angle(&self, _pos: BlockPos) -> f32 {
+        self.environment
+            .sample(self.world.day_time, None, None)
+            .sun_angle
+    }
     fn is_raining(&self) -> bool {
         self.raining
     }
@@ -871,8 +946,9 @@ impl LevelAccess for GameLevel<'_> {
     fn is_ticking_chunk(&self, chunk: horizon_core::position::ChunkPos) -> bool {
         self.tickets.block_ticking(chunk.x, chunk.z) && ticking_chunk(self.world, chunk.x, chunk.z)
     }
-    /// Entities that trigger pressure plates, tripwires and detector rails:
-    /// the players (the host and the LAN guests, mobs) and the minecarts.
+    /// Entities that trigger pressure plates, tripwires, detector rails and
+    /// wooden buttons: the players (the host and the LAN guests, mobs) and
+    /// the minecarts, and for `EntityQuery::Arrows` the arrows.
     fn count_entities(&self, area: Aabb, query: EntityQuery) -> usize {
         let hit = |(lo, hi): &([f64; 3], [f64; 3])| {
             area.intersects(Aabb::new(
@@ -881,6 +957,7 @@ impl LevelAccess for GameLevel<'_> {
             ))
         };
         let carts = || self.cart_boxes.iter().filter(|b| hit(b)).count();
+        let arrows = || self.arrow_boxes.iter().filter(|b| hit(b)).count();
         let players = || {
             self.player_box
                 .iter()
@@ -890,6 +967,7 @@ impl LevelAccess for GameLevel<'_> {
         };
         match query {
             EntityQuery::Minecart => carts(),
+            EntityQuery::Arrows => arrows(),
             EntityQuery::Mobs => players(),
             EntityQuery::Everything => players() + carts(),
         }
@@ -1205,6 +1283,8 @@ struct Game<'a> {
     pending_pack_reload: bool,
     /// A server's resource packs (game/server_packs.rs).
     server_packs: server_packs::ServerPackState,
+    /// The link a chat click asks to open (`ConfirmLinkScreen`).
+    link_prompt: Option<String>,
     dialogs: dialogs::DialogState,
     world_renderer_ready: bool,
     collision: &'a BlockCollisionRegistry<'a>,
@@ -1247,6 +1327,8 @@ struct Game<'a> {
     inv_clicks: horizon_client::container_screen::Clicks,
     /// The Mouse Tweaks extra's drag and wheel (`tweaks`).
     tweaks: tweaks::Tweaks,
+    /// The wheel and hovered slot of `BundleMouseActions`.
+    bundle_mouse: bundles::BundleMouse,
     /// The last inventory click, for the double click that gathers a stack.
     last_inv_click: Option<(std::time::Instant, usize, bool)>,
     /// `lastQuickMoved`: what the last Shift click moved, which a Shift
@@ -1310,6 +1392,8 @@ struct Game<'a> {
     /// Runs of `entity_vertices` by entity, for a shader pack's per-entity draws; recorded only
     /// while `pack_ids` is set (game/shader_packs.rs).
     entity_spans: std::cell::RefCell<Vec<horizon_client::gfx::pack_draw::EntitySpan>>,
+    /// The glowing entities' silhouettes this frame (game/glowing.rs).
+    glowing_vertices: std::cell::RefCell<Vec<Vertex>>,
     /// The shader pack's entity and block entity ids, while one draws entities.
     pack_ids: Option<shader_packs::PackIds>,
     started: Instant,
@@ -1414,6 +1498,10 @@ struct Game<'a> {
     titles: titles::Titles,
     /// `Hud.toolHighlightTimer`: the selected item name.
     tool_highlight: horizon_client::hud_overlays::ToolHighlight,
+    /// `Hud.autosaveIndicatorValue`.
+    saving_indicator: horizon_client::hud_overlays::SavingIndicator,
+    /// This game's world is autosaving this tick (`MinecraftServer.isSaving`).
+    autosaving: bool,
     applied_modifiers: Vec<(String, String)>,
     experience: Experience,
     orbs: Vec<ExperienceOrb>,
@@ -1441,6 +1529,8 @@ struct Game<'a> {
     /// `ClientAvatarState`: walked distance and view bob.
     avatar: horizon_client::camera::AvatarBob,
     flash: u32,
+    /// `ClientLevel.rainSoundTime`: ticks of rain since the last rain sound.
+    rain_sound_time: i32,
     /// Bolts that struck here and sky flashes they made, in total (`status`).
     lightning_seen: [u32; 2],
     /// The head of the bed while sleeping; the visual timer also survives waking.
@@ -1523,10 +1613,19 @@ struct Game<'a> {
     /// Map textures waiting for the next HUD batch to upload them.
     map_patches: Vec<horizon_client::font::Patch>,
     text_displays: std::collections::HashMap<i32, text_displays::RemoteTextDisplay>,
+    /// The fence knots a server tracks to this client, by entity id, at their
+    /// block (`LeashFenceKnotEntity`).
+    remote_knots: HashMap<u32, [i32; 3]>,
+    /// The entity ids a hosted server gives the knots its mobs hang on, by
+    /// block, while a lead is tied there.
+    knot_ids: HashMap<[i32; 3], u32>,
     text_display_vertices: usize,
     /// Player skin downloads, and which skin each atlas skin slot holds
     /// (least recently shown first).
     skin_downloads: RefCell<horizon_client::skins::Downloader>,
+    /// `ProfileResolver.Cached`: `Dynamic` profiles (name- or id-only heads
+    /// and mannequins) resolve through the services in the background.
+    skin_profiles: RefCell<horizon_client::skins::Resolver>,
     skin_slots: Vec<(String, usize)>,
     /// Atlas trim slots in use: (sprite name, slot), least recently drawn first.
     trim_slots: Vec<(String, usize)>,
@@ -1640,12 +1739,13 @@ struct Game<'a> {
     guest_use: Option<GuestUse>,
     /// Level events of this tick for the guests, and the guest acting now.
     lan_events: Vec<(i32, [i32; 3], i32, Option<u32>)>,
+    lan_cushion_breaks: Vec<(horizon_world::registry::BlockStateId, [f64; 3])>,
     /// Block events (position, b0, b1, state) and entity events (id, event,
     /// position) for the guests.
     lan_block_events: Vec<([i32; 3], i32, i32, u32)>,
     lan_entity_events: Vec<(i32, i8, [f64; 3])>,
     /// Successful crits (attacking guest, hit entity), queued while the hub is taken.
-    lan_critical_hits: Vec<(Option<u32>, i32)>,
+    lan_critical_hits: Vec<(Option<u32>, i32, bool)>,
     /// Global level events for every guest (`ServerLevel.globalLevelEvent`).
     lan_global_events: Vec<(i32, [i32; 3], i32)>,
     /// `ContainerOpenersCounter`: how many players (the host and the guests)
@@ -1663,6 +1763,9 @@ struct Game<'a> {
     /// The acting guest's cooldowns, as (item, ticks): their packet needs the
     /// hub's item registry, which the guest's turn does not hold.
     guest_cooldowns: Vec<(Arc<str>, i32)>,
+    /// The acting guest's own entity events (`ServerPlayer.connection.send`),
+    /// sent with their entity id, which the guest's turn does not hold.
+    guest_entity_events: Vec<i8>,
     /// `broadcastToAdmins` lines a guest's command queued, sent once it
     /// returns: the line, whether operators get it and whether the console
     /// logs it.
@@ -1697,6 +1800,8 @@ struct Game<'a> {
     restore_player_state: bool,
     stats_ui: stats_screen::StatsUi,
     adv_ui: advancements_screen::AdvUi,
+    /// The Server Links screens' state (game/server_links.rs).
+    links_ui: server_links::LinksUi,
     camera_type: perspective::CameraType,
     fangs: fangs::FangState,
     /// The local player as a model (third person, the inventory).
@@ -1793,9 +1898,46 @@ impl Game<'_> {
     fn reach(&self) -> f64 {
         if self.creative { 5.0 } else { 4.5 }
     }
+    /// Outline shapes that depend on more than the block state, as one box
+    /// in block space: `LightBlock` and `ScaffoldingBlock.getShape` are a full
+    /// block while the main hand holds the block's own item
+    /// (`CollisionContext.isHoldingItem`), and `ShulkerBoxBlock.getShape`
+    /// grows with the lid (`ShulkerBoxBlockEntity.getBoundingBox`).
+    fn context_outline(&self, pos: [i32; 3], state: BlockStateId) -> Option<[f64; 6]> {
+        let name = &self.res.facts().get(state).name;
+        if matches!(&**name, "minecraft:light" | "minecraft:scaffolding") {
+            return self
+                .held()
+                .is_some_and(|s| *s.item == **name)
+                .then_some([0.0, 0.0, 0.0, 1.0, 1.0, 1.0]);
+        }
+        if !name.ends_with("shulker_box") {
+            return None;
+        }
+        let progress = self.be_anims.shulkers.get(&pos).map_or(0.0, |s| s.progress);
+        let facing = self
+            .pack
+            .assets
+            .registry
+            .state(state)
+            .and_then(|s| s.properties.get("facing").cloned());
+        let d = facing_offset(facing.as_deref().unwrap_or("up"));
+        let mut b = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0];
+        for a in 0..3 {
+            match d[a] {
+                1 => b[a + 3] += 0.5 * f64::from(progress),
+                -1 => b[a] -= 0.5 * f64::from(progress),
+                _ => {}
+            }
+        }
+        Some(b)
+    }
     /// A block's outline boxes in world space (`getShape` plus the random offset).
     fn outline_boxes(&self, pos: [i32; 3]) -> Vec<[f64; 6]> {
         let state = self.world.block(pos[0], pos[1], pos[2]);
+        if let Some(b) = self.context_outline(pos, state) {
+            return vec![std::array::from_fn(|i| f64::from(pos[i % 3]) + b[i])];
+        }
         let f = self.res.facts().get(state);
         let o = if f.outline_offset {
             self.pack
@@ -1965,9 +2107,11 @@ impl Game<'_> {
     /// item in use (LocalPlayer.modifyInput), the helmet's Respiration
     /// (decreaseAirSupply), the wings, leather boots on powder snow
     /// (PowderSnowBlock.canEntityWalkOnPowderSnow), freeze-immune wear
-    /// (LivingEntity.canFreeze) and the dimension's FAST_LAVA.
+    /// (LivingEntity.canFreeze), the dimension's FAST_LAVA and the sleeping
+    /// pose.
     pub(crate) fn sync_player_body(&mut self) {
         let glider = self.glider_worn();
+        let sleeping = self.sleeping.is_some();
         let item_use_speed = self
             .using
             .and_then(|(slot, _)| {
@@ -1995,6 +2139,7 @@ impl Game<'_> {
         player.item_use_speed = item_use_speed;
         player.respiration = respiration;
         player.glider = glider;
+        let _ = player.set_sleeping(sleeping);
         player.leather_boots = leather_boots;
         player.freeze_immune = freeze_immune;
         player.fluids.fast_lava = self.dim == Dim::Nether;
@@ -2090,6 +2235,33 @@ impl Game<'_> {
     }
     /// `TerrainParticle` at `pos`: the model's particle sprite and tint source
     /// 0's `colorAsTerrainParticle` (white when the block has none).
+    /// `HoneyBlock.showSlideParticles` (entity event 53): five honey block
+    /// particles at the entity.
+    fn honey_slide_particles(&mut self, at: [f64; 3]) {
+        use horizon_client::particles::{ParticleOptions, ParticleType};
+        let Some(honey) = self
+            .pack
+            .assets
+            .registry
+            .default_state("minecraft:honey_block")
+        else {
+            return;
+        };
+        let block = [
+            at[0].floor() as i32,
+            at[1].floor() as i32,
+            at[2].floor() as i32,
+        ];
+        if let Some((sprite, tint)) = self.particle_sprite(honey, block) {
+            for _ in 0..5 {
+                self.particles.add(
+                    &ParticleOptions::block(ParticleType::Block, sprite.clone(), tint),
+                    at,
+                    [0.0; 3],
+                );
+            }
+        }
+    }
     fn particle_sprite(&self, state: BlockStateId, pos: [i32; 3]) -> Option<(String, u32)> {
         let sprite = Self::block_particle_sprite(&self.pack, state)?;
         let chunks = &self.world.chunks;
@@ -2225,8 +2397,9 @@ impl Game<'_> {
             ticks: 0,
         });
     }
-    /// `Block.getDrops`: the block's loot table, drawing from its server random
-    /// sequence (`LootContext.Builder.create`), else the level random.
+    /// `Block.getDrops` for a block a player breaks: the block's loot table
+    /// with the player as `this`, drawing from its server random sequence
+    /// (`LootContext.Builder.create`), else the level random.
     fn block_loot_at(
         &mut self,
         pos: [i32; 3],
@@ -2240,9 +2413,9 @@ impl Game<'_> {
                 let random = self.rand_sequences.get(&sequence, self.level.seed);
                 self.res
                     .items()
-                    .block_drops_with(registry, state, held, &dynamic, random)
+                    .block_drops_by_player(registry, state, held, &dynamic, random)
             }
-            None => self.res.items().block_drops_with(
+            None => self.res.items().block_drops_by_player(
                 registry,
                 state,
                 held,
@@ -2286,11 +2459,13 @@ impl Game<'_> {
         // Player.drop: the drop statistics.
         self.stats.add("dropped", &thrown.item, thrown.count as i32);
         self.stats.custom("drop", 1);
-        self.throw_from_eyes(thrown, eye);
+        self.throw_from_eyes(thrown, eye, true);
     }
     /// `Player.createItemStackToDrop`: an item entity thrown from the eyes
-    /// along the view direction.
-    fn throw_from_eyes(&mut self, thrown: ItemStack, eye: [f64; 3]) {
+    /// along the view direction. `thrown_from_hand` (`drop(stack, true)`, the
+    /// drop key) names the player as the thrower; `drop(stack, false)`, for
+    /// what no longer fits in the inventory, does not.
+    fn throw_from_eyes(&mut self, thrown: ItemStack, eye: [f64; 3], thrown_from_hand: bool) {
         let (yaw, pitch) = (
             f64::from(self.yaw).to_radians(),
             f64::from(self.pitch).to_radians(),
@@ -2304,11 +2479,18 @@ impl Game<'_> {
             yaw.cos() * pitch.cos() * 0.3 + spread.sin() * strength,
         ];
         self.spawn_item(thrown, [eye[0], eye[1] - 0.3, eye[2]], v, 40);
-        if self.lan_acting.is_none() {
-            let uuid = self.level.ensure_player_uuid();
+        if thrown_from_hand {
+            let uuid = self.acting_player_uuid();
             self.dropped.last_mut().unwrap().thrower = Some(uuid);
         }
     }
+    /// The UUID of the player acting: the guest whose turn it is, else the host.
+    pub(super) fn acting_player_uuid(&mut self) -> [i32; 4] {
+        match self.lan_acting_uuid {
+            Some(guest) => horizon_client::lan::playerdata::uuid_ints(guest),
+            None => self.level.ensure_player_uuid(),
+        }
+    }
     fn tick_items(&mut self) {
         let mut items = std::mem::take(&mut self.dropped);
         // ServerLevel.tick: only entities in entity-ticking chunks tick.
@@ -2345,6 +2527,15 @@ impl Game<'_> {
                 no_physics,
                 &self.res.motion().fluids,
             );
+            // Entity.applyEffectsFromBlocks: bubble columns lift or drag the item.
+            horizon_client::motion::bubble_column_push(
+                &self.world,
+                self.pack.assets.registry,
+                self.res.facts(),
+                self.collision,
+                item.bounds(),
+                &mut item.velocity,
+            );
             cells.moved(i, item.previous, item.position);
             // ItemEntity.tick: merge every 2 ticks while moving between
             // blocks, every 40 otherwise, before the lifetime check.
@@ -2453,8 +2644,14 @@ impl Game<'_> {
                                 pickups::Taken::Item(Box::new(item.clone())),
                                 pickups::Collector::Player,
                             );
+                            // handleTakeItemEntity: the random pitch of a full pickup.
+                            let pitch = ((self.world.random.next_float()
+                                - self.world.random.next_float())
+                                * 0.7
+                                + 1.0)
+                                * 2.0;
                             self.audio
-                                .play("minecraft:entity.item.pickup", Some(feet), 0.2, 1.0);
+                                .play("minecraft:entity.item.pickup", Some(feet), 0.2, pitch);
                         }
                         item.stack = rest;
                     }
@@ -2511,6 +2708,19 @@ impl Game<'_> {
                 )
             })
             .collect();
+        let cart_signals = self.cart_signals();
+        let arrow_boxes = self
+            .creatures
+            .projectiles
+            .iter()
+            .filter(|p| p.arrow.is_some())
+            .map(|p| p.position)
+            .chain(self.tridents.iter().map(|t| t.position))
+            .map(|at| {
+                let b = horizon_client::arrows::arrow_bounds(at);
+                (b.min_position().components(), b.max_position().components())
+            })
+            .collect();
         let guest_boxes = self.lan_block_trigger_boxes();
         let dimension = match self.dim {
             Dim::Overworld => LevelDimension::Overworld,
@@ -2541,6 +2751,8 @@ impl Game<'_> {
         };
         let mut level = GameLevel {
             cart_boxes,
+            cart_signals,
+            arrow_boxes,
             blockers,
             world: &mut self.world,
             facts: self.res.facts(),
@@ -2548,6 +2760,11 @@ impl Game<'_> {
             events: &mut self.level_events,
             dimension,
             darken,
+            environment: match dimension {
+                LevelDimension::Overworld => self.res.environment(),
+                LevelDimension::Nether => self.res.nether_environment(),
+                LevelDimension::End => self.res.end_environment(),
+            },
             raining: rain > 0.2,
             thundering: thunder > 0.9,
             player_box,
@@ -2589,9 +2806,13 @@ impl Game<'_> {
         self.process_level_events()
     }
     fn attack_block(&mut self, pos: [i32; 3]) -> Result<()> {
-        self.with_level(|b, level, ticks| {
-            b.attack_block(level, ticks, BlockPos::new(pos[0], pos[1], pos[2]));
+        let note = self.with_level(|b, level, ticks| {
+            b.attack_block(level, ticks, BlockPos::new(pos[0], pos[1], pos[2]))
         });
+        // NoteBlock.attack awards the statistic.
+        if note {
+            self.stats.custom("play_noteblock", 1);
+        }
         self.process_level_events()
     }
     /// Track which chunks are ticking (Ticks needs chunk load/unload).
@@ -2674,8 +2895,9 @@ impl Game<'_> {
             .copied()
             .filter(|&(x, z)| levels.random_ticking(x, z) && ticking_chunk(&self.world, x, z))
             .collect();
-        // Entity.checkInsideBlocks for the plates, tripwires and detector rails
-        // under the players (the host and the LAN guests) and the minecarts.
+        // Entity.checkInsideBlocks for the plates, tripwires, detector rails and
+        // buttons under the players (the host and the LAN guests), the minecarts
+        // and the arrows.
         let mut inside = Vec::new();
         let guests = self.lan_block_trigger_boxes();
         let boxes = self
@@ -2707,6 +2929,24 @@ impl Game<'_> {
                 }
             }
         }
+        // AbstractArrow.applyEffectsFromBlocks: the blocks every arrow passed
+        // through this tick (a wooden button is pressed by one inside it), and
+        // the ones a thrown trident is in.
+        for p in self
+            .creatures
+            .projectiles
+            .iter()
+            .filter(|p| p.arrow.is_some())
+        {
+            inside.extend(horizon_client::arrows::blocks_inside(
+                p.previous, p.position,
+            ));
+        }
+        for t in &self.tridents {
+            inside.extend(horizon_client::arrows::blocks_inside(
+                t.position, t.position,
+            ));
+        }
         // BigDripleafBlock.entityInside also asks whether the player stands on
         // the ground and how high its feet are: the leaves its box's feet
         // layer is inside (the host and the LAN guests).
@@ -2768,20 +3008,29 @@ impl Game<'_> {
             b.run_block_events(level, ticks);
             b.tick_block_entities(level, ticks);
         });
+        // `PistonMovingBlockEntity.tick` pushes what its block just ran into,
+        // with the progress it is about to take.
+        let pushes = std::mem::take(&mut self.block_ticks.piston_pushes);
+        self.push_piston_entities(pushes);
+        self.process_level_events()?;
         self.sync_moving_pistons();
-        self.process_level_events()
+        Ok(())
     }
     /// Copies the moving-piston block entities into the world, where the
     /// collision queries and the renderer read them.
     fn sync_moving_pistons(&mut self) {
-        let pistons = &mut self.world.moving_pistons;
-        pistons.clear();
-        pistons.extend(
-            self.block_ticks
-                .moving_pistons
-                .iter()
-                .map(|(p, piston)| ([p.x, p.y, p.z], piston.shape_state())),
-        );
+        let previous = std::mem::take(&mut self.world.moving_pistons);
+        let current: Vec<_> = self
+            .block_ticks
+            .moving_pistons
+            .iter()
+            .map(|(p, piston)| ([p.x, p.y, p.z], piston.shape_state()))
+            .collect();
+        self.world.moving_piston_fallback = previous
+            .into_iter()
+            .filter(|(pos, _)| !current.iter().any(|(next, _)| next == pos))
+            .collect();
+        self.world.moving_pistons = current;
     }
     /// `ServerLevel.tick`'s scheduled block then fluid ticks, one at a time:
     /// the side effects of each (a shrieker summoning a warden, drops, game
@@ -2844,6 +3093,16 @@ impl Game<'_> {
                     data,
                 } => self.sculk_charge_event(pos, data),
                 LevelEvent::LevelEvent { id: 3007, pos, .. } => self.shriek_event(pos),
+                // LevelEventHandler 2019 and 2020: the crack on a face of the
+                // block being mined, with its hit sound for 2020.
+                LevelEvent::LevelEvent {
+                    id: id @ (2019 | 2020),
+                    pos,
+                    data,
+                } => {
+                    let face = horizon_core::geometry::Direction::ALL[data.clamp(0, 5) as usize];
+                    self.breaking_block_effects([pos.x, pos.y, pos.z], face.normal(), id == 2020);
+                }
                 LevelEvent::LevelEvent { id: 2004, pos, .. } => {
                     self.spawner_burst([pos.x, pos.y, pos.z])
                 }
@@ -2863,6 +3122,11 @@ impl Game<'_> {
                     pos,
                     data,
                 } => self.dragon_egg_particles([pos.x, pos.y, pos.z], data),
+                LevelEvent::LevelEvent {
+                    id: 2016,
+                    pos,
+                    data,
+                } => self.shulker_teleport_particles([pos.x, pos.y, pos.z], data),
                 LevelEvent::LevelEvent {
                     id: 2017,
                     pos,
@@ -2876,6 +3140,17 @@ impl Game<'_> {
                     pos,
                     data,
                 } => self.smash_dust(pos, data),
+                // LevelEventHandler 2002 and 2007: a potion's splash.
+                LevelEvent::LevelEvent {
+                    id: 2002,
+                    pos,
+                    data,
+                } => self.potion_splash_particles(pos, data, false),
+                LevelEvent::LevelEvent {
+                    id: 2007,
+                    pos,
+                    data,
+                } => self.potion_splash_particles(pos, data, true),
                 LevelEvent::LevelEvent {
                     id: id @ 3002..=3005,
                     pos,
@@ -2886,6 +3161,34 @@ impl Game<'_> {
                     pos,
                     data,
                 } => self.composter_fill_event(pos, data == 1),
+                // LevelEventHandler 1504: the stalactite's drip particle.
+                LevelEvent::LevelEvent { id: 1504, pos, .. } => self.dripstone_drip_particle(pos),
+                // LevelEventHandler 2006: the dragon fireball's burst.
+                LevelEvent::LevelEvent {
+                    id: 2006,
+                    pos,
+                    data,
+                } => self.dragon_fireball_burst(pos, data),
+                // LevelEventHandler 2009: a wet sponge drying.
+                LevelEvent::LevelEvent { id: 2009, pos, .. } => {
+                    self.puffs_above_block(pos, horizon_client::particles::ParticleType::Cloud)
+                }
+                // LevelEventHandler 2012: a turtle egg laid.
+                LevelEvent::LevelEvent {
+                    id: 2012,
+                    pos,
+                    data,
+                } => self.turtle_egg_particles(pos, data),
+                // LevelEventHandler 2014: a straw bed destroyed, with no sound.
+                LevelEvent::LevelEvent {
+                    id: 2014,
+                    pos,
+                    data,
+                } => self.destroy_particles([pos.x, pos.y, pos.z], BlockStateId(data as u32)),
+                // LevelEventHandler 3009: a sniffer egg cracking.
+                LevelEvent::LevelEvent { id: 3009, pos, .. } => {
+                    self.sniffer_egg_crack_particles(pos)
+                }
                 LevelEvent::LevelEvent {
                     id: id @ 3011..=3021,
                     pos,
@@ -2901,6 +3204,19 @@ impl Game<'_> {
                         1501 => Some(("minecraft:block.lava.extinguish", 0.5)),
                         1009 => Some(("minecraft:block.fire.extinguish", 0.5)),
                         1502 => Some(("minecraft:block.redstone_torch.burnout", 0.5)),
+                        1033 => Some(("minecraft:block.chorus_flower.grow", 1.0)),
+                        1034 => Some(("minecraft:block.chorus_flower.death", 1.0)),
+                        1046 => Some((
+                            "minecraft:block.pointed_dripstone.drip_lava_into_cauldron",
+                            2.0,
+                        )),
+                        1047 => Some((
+                            "minecraft:block.pointed_dripstone.drip_water_into_cauldron",
+                            2.0,
+                        )),
+                        // LevelEvent.SOUND_ZOMBIE_WOODEN_DOOR (attack, break).
+                        1019 => Some(("minecraft:entity.zombie.attack_wooden_door", 2.0)),
+                        1021 => Some(("minecraft:entity.zombie.break_wooden_door", 2.0)),
                         1030 => Some(("minecraft:block.anvil.use", 1.0)),
                         1029 => Some(("minecraft:block.anvil.destroy", 1.0)),
                         1031 => Some(("minecraft:block.anvil.land", 0.3)),
@@ -2908,6 +3224,8 @@ impl Game<'_> {
                         1044 => Some(("minecraft:block.smithing_table.use", 1.0)),
                         // LevelEvent.SOUND_PAGE_TURN (a lectern's page).
                         1043 => Some(("minecraft:item.book.page_turn", 1.0)),
+                        // LevelEvent.SOUND_SPLASH_POTION and its instant twin.
+                        1053 | 1054 => Some(("minecraft:entity.splash_potion.break", 1.0)),
                         _ => None,
                     };
                     if let Some((name, volume)) = sound {
@@ -2917,12 +3235,24 @@ impl Game<'_> {
                                     - self.world.random.next_float())
                                     * 0.8
                             }
-                            1029 | 1030 | 1042 | 1043 | 1044 => {
+                            // LevelEventHandler draws these from the client
+                            // level's random, before 1501's and 1502's smoke.
+                            1501 | 1502 => {
+                                let r = self.particles.level_random();
+                                2.6 + (r.next_float() - r.next_float()) * 0.8
+                            }
+                            1046 | 1047 => self.particles.level_random().next_float() * 0.1 + 0.9,
+                            1029 | 1030 | 1042 | 1043 | 1044 | 1053 | 1054 => {
                                 self.world.random.next_float() * 0.1 + 0.9
                             }
+                            1019 | 1021 => {
+                                (self.world.random.next_float() - self.world.random.next_float())
+                                    * 0.2
+                                    + 1.0
+                            }
                             _ => 1.0,
                         };
-                        if matches!(id, 1029 | 1030) {
+                        if matches!(id, 1019 | 1021 | 1029 | 1030 | 1053 | 1054) {
                             // Clients play the anvil sound from its level event;
                             // capturing it also sends a duplicate sound packet.
                             self.audio.play_unshared(name, c, volume, pitch);
@@ -2930,6 +3260,15 @@ impl Game<'_> {
                             self.audio.play(name, c, volume, pitch);
                         }
                     }
+                    // LevelEventHandler 1501 and 1502 draw their smoke after the sound.
+                    match id {
+                        1501 => self.puffs_above_block(
+                            pos,
+                            horizon_client::particles::ParticleType::LargeSmoke,
+                        ),
+                        1502 => self.torch_burnout_smoke(pos),
+                        _ => {}
+                    }
                 }
                 LevelEvent::Sound {
                     pos,
@@ -2971,11 +3310,9 @@ impl Game<'_> {
                         drop_item: true,
                         fall_distance: 0.0,
                         stuck: Vec3::ZERO,
-                        damage: if self.res.facts().get(state).name.ends_with("anvil") {
-                            horizon_client::falling_block::Damage::anvil()
-                        } else {
-                            Default::default()
-                        },
+                        damage: horizon_client::falling_block::Damage::falling(
+                            &self.res.facts().get(state).name,
+                        ),
                         saved: None,
                     });
                 }
@@ -2998,6 +3335,8 @@ impl Game<'_> {
                     // Popped as the behaviour emits it (GameLevel::emit).
                     PlayerEffect::DropItem(_) => {}
                     PlayerEffect::EatCake => {
+                        // CakeBlock.eat
+                        self.stats.custom("eat_cake_slice", 1);
                         if let Some(p) = self.player.as_mut() {
                             let food = &mut p.health.food;
                             food.food = (food.food + 2).min(20);
@@ -3052,6 +3391,11 @@ impl Game<'_> {
                     kind: "hatch_sniffer",
                     ..
                 } => self.hatch_sniffer([pos.x, pos.y, pos.z]),
+                LevelEvent::BlockEvent {
+                    pos,
+                    state,
+                    kind: "hatch_turtles",
+                } => self.hatch_turtles([pos.x, pos.y, pos.z], state),
                 LevelEvent::BlockEvent {
                     pos,
                     kind: "portal_spawn",
@@ -3073,6 +3417,31 @@ impl Game<'_> {
                 LevelEvent::BlockEntityEvent { pos, a, b, .. } => {
                     self.block_entity_event([pos.x, pos.y, pos.z], a, b)
                 }
+                // NoteBlock.triggerEvent: a NOTE particle above, coloured by
+                // the note (`note / 24.0` in the x speed).
+                LevelEvent::BlockEvent {
+                    pos,
+                    state,
+                    kind: "note_particle",
+                } => {
+                    use horizon_client::particles::{ParticleOptions, ParticleType};
+                    let note = self
+                        .pack
+                        .assets
+                        .registry
+                        .state(state)
+                        .and_then(|s| s.properties.get("note")?.parse::<f64>().ok())
+                        .unwrap_or(0.0);
+                    self.particles.add(
+                        &ParticleOptions::simple(ParticleType::Note),
+                        [
+                            f64::from(pos.x) + 0.5,
+                            f64::from(pos.y) + 1.2,
+                            f64::from(pos.z) + 0.5,
+                        ],
+                        [note / 24.0, 0.0, 0.0],
+                    );
+                }
                 LevelEvent::GrowTree { .. }
                 | LevelEvent::PlaceFeature { .. }
                 | LevelEvent::BlockEvent { .. } => {}
@@ -3089,6 +3458,10 @@ impl Game<'_> {
             .name
             .clone();
         let key = (pos[0], pos[1], pos[2]);
+        if self.chest_menu_blocked(key, &name) {
+            // The use still succeeds, but no menu, stat or piglin anger.
+            return;
+        }
         if &*name == "minecraft:lectern" {
             self.open_lectern(pos);
             return;
@@ -3097,20 +3470,21 @@ impl Game<'_> {
             self.open_command_block(key);
             return;
         }
+        // SignBlock.useWithoutItem: the text editor, not a container.
+        if horizon_client::signs::sign_kind(&name).is_some() {
+            self.use_sign_empty_hand(pos);
+            return;
+        }
         if &*name == "minecraft:crafting_table" {
             self.craft_size = 3;
             self.craft_table = Some(pos);
         } else if &*name == "minecraft:ender_chest" {
             self.open_ender_chest(key);
-            self.container_opener_event(key, true);
-            let at = [
-                f64::from(key.0) + 0.5,
-                f64::from(key.1) + 0.5,
-                f64::from(key.2) + 0.5,
-            ];
-            let pitch = self.world.random.next_float() * 0.1 + 0.9;
-            self.audio
-                .play("minecraft:block.ender_chest.open", Some(at), 0.5, pitch);
+            // EnderChestBlock.useWithoutItem
+            self.stats.custom("open_enderchest", 1);
+            if self.container_opener_event(key, true) {
+                self.container_edge_sound(key, true);
+            }
         } else if &*name == "minecraft:beacon" && self.open_station(pos, &name) {
             self.world.block_entities.get_or_insert_with(key, || {
                 BlockEntity::for_block(&name).unwrap_or(BlockEntity::Chest(Vec::new()))
@@ -3126,7 +3500,7 @@ impl Game<'_> {
             ];
             self.resolve_container_maps(key, centre);
             self.container = Some(key);
-            self.container_opener_event(key, true);
+            let first = self.container_opener_event(key, true);
             self.post_block_game_event(
                 "minecraft:container_open",
                 [key.0, key.1, key.2],
@@ -3150,26 +3524,8 @@ impl Game<'_> {
             if self.guarded_by_piglins(&name) {
                 self.anger_piglins(true);
             }
-            let sound = if storage::is_shulker_box(&name) {
-                Some("minecraft:block.shulker_box.open")
-            } else if name.contains("chest") {
-                Some("minecraft:block.chest.open")
-            } else if &*name == "minecraft:barrel" {
-                Some("minecraft:block.barrel.open")
-            } else {
-                None
-            };
-            if let Some(sound) = sound {
-                self.audio.play(
-                    sound,
-                    Some([
-                        f64::from(key.0) + 0.5,
-                        f64::from(key.1) + 0.5,
-                        f64::from(key.2) + 0.5,
-                    ]),
-                    0.5,
-                    1.0,
-                );
+            if first {
+                self.container_edge_sound(key, true);
             }
         } else if self.open_station(pos, &name) {
             // Workstation menus: game/stations.rs.
@@ -3444,7 +3800,7 @@ impl Game<'_> {
         } else if let Some(tag) = spill::saved_entity(&self.world, pos) {
             self.pending.record_saved(pos, &tag);
         }
-        self.creaking_heart_broken(pos);
+        self.creaking_heart_broken(pos, true);
         let hive = match self.world.block_entities.get(&key) {
             Some(BlockEntity::Beehive(h)) => self.hive_state(pos).map(|s| ((**h).clone(), s)),
             _ => None,
@@ -3493,6 +3849,21 @@ impl Game<'_> {
                 {
                     self.hive_broken_by_player(pos, hive, honey, facing);
                 }
+                // InfestedBlock.spawnAfterBreak: its silverfish comes out unless the
+                // tool has silk touch (#prevents_infested_spawns) or blocks don't drop.
+                if facts.name.starts_with("minecraft:infested_")
+                    && !silk
+                    && self.ui.rules.bool("block_drops")
+                {
+                    let at = [
+                        f64::from(pos[0]) + 0.5,
+                        f64::from(pos[1]),
+                        f64::from(pos[2]) + 0.5,
+                    ];
+                    if let Some(id) = self.spawn_mob("minecraft:silverfish", at, false) {
+                        self.mob_poof(id);
+                    }
+                }
                 // SpawnerBlock.spawnAfterBreak pops its experience whatever the tool.
                 let xp = if silk && &*facts.name != "minecraft:spawner" {
                     0
@@ -3614,6 +3985,10 @@ impl Game<'_> {
                 self.swing_arm();
                 return Ok(true);
             }
+            if self.use_sign_applicator(hit.pos, held.as_ref()) {
+                self.swing_arm();
+                return Ok(true);
+            }
             if self.use_jukebox(hit.pos, held.as_ref()) {
                 self.swing_arm();
                 return Ok(true);
@@ -3634,6 +4009,10 @@ impl Game<'_> {
                 self.swing_arm();
                 return Ok(true);
             }
+            if self.use_beehive(hit.pos, held.as_ref())? {
+                self.swing_arm();
+                return Ok(true);
+            }
             if self.use_campfire_douse(hit.pos, held.as_ref())? {
                 self.swing_arm();
                 return Ok(true);
@@ -3673,6 +4052,20 @@ impl Game<'_> {
                     )
                 });
                 self.process_level_events()?;
+                // NoteBlock.useWithoutItem (tuned) and BellBlock.onHit (rung).
+                if result == horizon_world::level::InteractionResult::Success {
+                    let name = self
+                        .res
+                        .facts()
+                        .get(self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]))
+                        .name
+                        .clone();
+                    match &*name {
+                        "minecraft:note_block" => self.stats.custom("tune_noteblock", 1),
+                        "minecraft:bell" => self.stats.custom("bell_ring", 1),
+                        _ => {}
+                    }
+                }
                 if result.consumes_action() {
                     self.swing_arm();
                     return Ok(true);
@@ -3976,6 +4369,8 @@ impl Game<'_> {
             self.release_used_item(&stack, ticks, hand_changed);
             return;
         }
+        // ServerPlayer.updateUsingItem: USING_ITEM every tick of the use.
+        self.trigger_using_item(&stack);
         let Some(info) = self.res.items().get(&stack.item).cloned() else {
             self.using = None;
             return;
@@ -4003,6 +4398,7 @@ impl Game<'_> {
         if &*stack.item == "minecraft:spyglass" {
             // SpyglassItem.USE_DURATION, then finishUsingItem.
             if ticks + 1 >= 1200 {
+                self.send_use_item_complete();
                 self.stop_spyglass();
                 self.using = None;
             } else {
@@ -4024,6 +4420,7 @@ impl Game<'_> {
         }
         if ticks >= duration {
             self.using = None;
+            self.send_use_item_complete();
             // ItemStack.finishUsingItem's applyAfterUseComponentSideEffects.
             self.apply_use_cooldown(&stack);
             self.finish_consuming(&info, consumable, &stack);
@@ -4042,6 +4439,17 @@ impl Game<'_> {
             _ => {}
         }
     }
+    /// `ServerPlayerGameMode.tick` while a player digs: level event 2020 every
+    /// fourth tick since the START (the hit sound), else 2019 (the crack only),
+    /// for everyone around, the digger included (`levelEvent(null, ...)`).
+    fn destroy_progress_event(&mut self, pos: [i32; 3], face: [i32; 3], ticks: u32) {
+        let id = if ticks.is_multiple_of(4) { 2020 } else { 2019 };
+        let direction = horizon_core::geometry::Direction::ALL
+            .iter()
+            .position(|d| d.normal() == face)
+            .unwrap_or(1);
+        self.level_event_at(id, pos, direction as i32);
+    }
     fn tick_mining(&mut self) -> Result<()> {
         if self.destroy_delay > 0 {
             self.destroy_delay -= 1;
@@ -4085,6 +4493,11 @@ impl Game<'_> {
         let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]);
         let facts = self.res.facts().get(state);
         if facts.hardness < 0.0 {
+            // The server still counts its destroy ticks on an unbreakable block.
+            let m = self.mining.as_mut().ok_or("mining")?;
+            m.ticks += 1;
+            let (pos, ticks) = (m.pos, m.ticks);
+            self.destroy_progress_event(pos, hit.face, ticks);
             return Ok(());
         }
         // Player.getDestroySpeed / BlockBehaviour.getDestroyProgress.
@@ -4115,26 +4528,15 @@ impl Game<'_> {
         } else {
             speed / facts.hardness / if harvest { 30.0 } else { 100.0 }
         };
-        let hit_sound = facts.sounds.clone();
         self.swing_arm();
         let m = self.mining.as_mut().ok_or("mining")?;
         m.progress += progress;
         m.ticks += 1;
-        let crack = (m.pos, hit.face);
-        if m.ticks % 4 == 1 {
-            let c = [
-                f64::from(m.pos[0]) + 0.5,
-                f64::from(m.pos[1]) + 0.5,
-                f64::from(m.pos[2]) + 0.5,
-            ];
-            self.audio.play(
-                &hit_sound.hit,
-                Some(c),
-                (hit_sound.volume + 1.0) / 8.0,
-                hit_sound.pitch * 0.5,
-            );
+        // An instant break at START sends no destroy events.
+        if m.progress < 1.0 || m.ticks > 1 {
+            let (pos, ticks) = (m.pos, m.ticks);
+            self.destroy_progress_event(pos, hit.face, ticks);
         }
-        self.crack_particle(crack.0, crack.1, state);
         let m = self.mining.as_mut().ok_or("mining")?;
         // ServerPlayerGameMode breaks a player's block at once only when it is instant (START's
         // insta-mine); otherwise it waits for the client's STOP_DESTROY_BLOCK
@@ -4236,6 +4638,12 @@ impl Game<'_> {
                 // The world's spawn from the start, not only once saved: a bed set
                 // before the first save must not become it.
                 self.level.world_spawn.get_or_insert([x, y, z]);
+                // The "Bonus Chest" create-world option, placed once with the spawn.
+                if horizon_client::save::WorldGen::read(&self.world_root)
+                    .is_some_and(|g| g.bonus_chest)
+                {
+                    self.place_bonus_chest([x, y, z])?;
+                }
             }
             let s = self
                 .level
@@ -4339,7 +4747,11 @@ impl Game<'_> {
             self.world.weather.tick_levels();
             self.tick_weather_effects();
         }
-        if self.ticks.is_multiple_of(6000) {
+        self.autosaving = self.ticks.is_multiple_of(6000);
+        if let Some(serving) = &self.serving {
+            serving.set_saving(self.autosaving);
+        }
+        if self.autosaving {
             self.save_game_with(false)?;
         }
         if running {
@@ -4435,12 +4847,6 @@ impl Game<'_> {
         let events = std::mem::take(&mut player.events);
         let spin_hit = player.spin_hit.take();
         let glider_wear = std::mem::take(&mut player.glider_wear);
-        if glider_wear > 0
-            && !self.creative
-            && let Some(elytra) = self.armor[1].as_mut()
-        {
-            elytra.damage += glider_wear;
-        }
         let feet = [player.position.x, player.position.y, player.position.z];
         let player_velocity = [player.velocity.x, player.velocity.y, player.velocity.z];
         self.previous_eye = self.eye;
@@ -4450,19 +4856,47 @@ impl Game<'_> {
             player.dimensions.eye_height
         };
         self.eye += (camera_eye.unwrap_or(eye_height) - self.eye) * 0.5;
-        let crouching = player.pose == horizon_client::pose::Pose::Crouching;
+        // `LivingEntity.baseTick` (Soul Speed) comes before `aiStep` (the
+        // glide's wear): both draw from the level random.
+        if let Some((at, velocity)) = self.tick_soul_speed() {
+            self.particles.send_particles(
+                &horizon_client::particles::ParticleOptions::simple(
+                    horizon_client::particles::ParticleType::Soul,
+                ),
+                at,
+                velocity,
+                1.0,
+                0,
+            );
+            if let Some(host) = self.lan.as_ref() {
+                lan_particles::send_soul_particle(host, at, velocity);
+            }
+        }
+        // `ItemStack.hurtAndBreak` for the glide: Unbreaking can save the wear.
+        if glider_wear > 0
+            && !self.creative
+            && let Some(stack) = self.armor[1].clone()
+        {
+            let loss = self.durability_loss(&stack, glider_wear);
+            if let Some(elytra) = self.armor[1].as_mut() {
+                elytra.damage += loss;
+            }
+        }
         self.tick_avatar(before, riding);
         self.end_spin_attack(spin_hit);
         self.record_combat(&events);
+        self.wear_armor(&events);
         for event in events {
             match event {
                 MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, feet),
                 MotionEvent::Emission {
                     state, in_water, ..
-                } if !crouching => {
+                } => {
                     let sounds = self.res.facts().get(state).sounds.clone();
                     // Entity.playStepSound: the block's step sound at 0.15 volume,
-                    // muffled under the swim sound in water.
+                    // muffled under the swim sound in water. Whether it plays is
+                    // Player.getMovementEmission's call (shift on the ground),
+                    // not the pose: a forced crouch still steps.
                     let (volume, pitch) = if in_water {
                         (sounds.volume * 0.05, sounds.pitch * 0.8)
                     } else {
@@ -4474,26 +4908,21 @@ impl Game<'_> {
                     self.audio
                         .play("minecraft:entity.player.swim", Some(feet), volume, pitch);
                 }
+                MotionEvent::Chime { volume, pitch } => {
+                    self.audio.play(
+                        "minecraft:block.amethyst_block.chime",
+                        Some(feet),
+                        volume,
+                        pitch,
+                    );
+                }
                 MotionEvent::Drown => {
-                    // LivingEntity.makeDrownParticles: eight bubbles moving
-                    // with the player.
-                    use horizon_client::particles::{ParticleOptions, ParticleType};
-                    for _ in 0..8 {
-                        let mut triangle = || {
-                            let r = self.particles.random();
-                            r.next_double() - r.next_double()
-                        };
-                        let p = [
-                            feet[0] + triangle(),
-                            feet[1] + triangle(),
-                            feet[2] + triangle(),
-                        ];
-                        self.particles.add(
-                            &ParticleOptions::simple(ParticleType::Bubble),
-                            p,
-                            player_velocity,
-                        );
+                    // The guests see the entity event 67 too.
+                    if let Some(host) = &self.lan {
+                        host.hub
+                            .entity_event(host.host_entity, combat::DROWN_EVENT, feet);
                     }
+                    self.drown_particles(feet, player_velocity);
                 }
                 MotionEvent::BubbleColumnParticle { bubble, position } => {
                     // ServerLevel.sendParticles: SPLASH (speed 1) or BUBBLE
@@ -4529,9 +4958,36 @@ impl Game<'_> {
                     };
                     self.audio.play(name, Some(feet), volume, pitch);
                 }
+                // Player.causeFallDamage: a fall of 2 blocks or more counts.
+                MotionEvent::Fall(horizon_client::landing::FallEvent::Statistic(cm)) => {
+                    self.stats.custom("fall_one_cm", cm)
+                }
+                // LivingEntity.checkFallDamage: the block's crumbs where the fall landed.
+                MotionEvent::Fall(horizon_client::landing::FallEvent::Particles {
+                    state,
+                    position,
+                    count,
+                    speed,
+                }) => self.landing_dust(None, state, position, count, speed),
                 MotionEvent::Fall(event) => self.landing_block_updates(&event),
                 MotionEvent::Snowflake { position, velocity } => self.snowflake(position, velocity),
                 MotionEvent::EnterBlock { state } => self.trigger_enter_block(state),
+                MotionEvent::HoneySlide {
+                    sound, particles, ..
+                } => {
+                    if sound {
+                        self.audio
+                            .play("minecraft:block.honey_block.slide", Some(feet), 1.0, 1.0);
+                    }
+                    if particles {
+                        self.honey_slide_particles(feet);
+                        // The server's event 53 reaches the guests too.
+                        let id = self.lan.as_ref().map(|h| h.host_entity);
+                        if let Some(id) = id {
+                            self.lan_entity_event(id, 53, feet);
+                        }
+                    }
+                }
                 MotionEvent::InsidePortal { pos } => self.player_inside_nether_portal(pos),
                 MotionEvent::CauldronExtinguish { pos } => self.cauldron_extinguish(pos),
                 MotionEvent::InsideWitherRose => self.wither_rose_contact(),
@@ -4573,6 +5029,7 @@ impl Game<'_> {
             }
         }
         self.powder_snow_fire()?;
+        self.rain_extinguish_in_frame();
         self.tick_totem();
         let Some(player) = self.player.as_mut() else {
             return Ok(());
@@ -4614,9 +5071,14 @@ impl Game<'_> {
             if let Some(host) = &self.lan {
                 host.hub.entity_event(host.host_entity, 3, feet);
             }
-            self.screen = Screen::Dead;
-            self.capture(false);
-            self.ui.death_time = 0;
+            if self.ui.rules.bool("immediate_respawn") {
+                // Gui.setScreen: without the death screen the player respawns at once.
+                self.respawn_player()?;
+            } else {
+                self.screen = Screen::Dead;
+                self.capture(false);
+                self.ui.death_time = 0;
+            }
         } else if dead {
             // LivingEntity.tickDeath: 20 ticks after dying the player is
             // removed, and Player.remove's inventoryMenu.removed drops what
@@ -4626,7 +5088,7 @@ impl Game<'_> {
                 && let Some(stack) = self.carried.take()
                 && let Some(eye) = self.eye_position()
             {
-                self.throw_from_eyes(stack, eye);
+                self.throw_from_eyes(stack, eye, false);
             }
         }
         self.tick_world(running)
@@ -4634,6 +5096,7 @@ impl Game<'_> {
     /// What the tick runs after the local player's own update: effects, the
     /// world's entities and blocks, and the network hub.
     fn tick_world(&mut self, running: bool) -> Result<()> {
+        self.share_spawn_conditions();
         self.update_chunk_tickets();
         horizon_client::spans::time("tick_effects", || self.tick_effects(running));
         // Player.tick's ItemCooldowns.tick for the window's player (a
@@ -4641,6 +5104,7 @@ impl Game<'_> {
         self.shield_cooldown = self.shield_cooldown.saturating_sub(1);
         self.cooldowns.tick();
         horizon_client::spans::time("tick_using", || self.tick_using());
+        self.tick_bundle_hover();
         horizon_client::spans::time("tick_hud", || self.tick_hud());
         // The player's digging comes in with its packets, before the level
         // ticks; ServerLevel.tick then runs the scheduled and random block
@@ -4843,6 +5307,9 @@ impl Game<'_> {
                     | Screen::Advancements
                     | Screen::WorldOptions
                     | Screen::Friends
+                    | Screen::ServerLinks
+                    | Screen::ConfirmLink
+                    | Screen::DialogWarning
                     | Screen::CommandBlock
             ) || self.book.is_some()
                 || self.win_screen_pauses())
@@ -4864,10 +5331,13 @@ impl Game<'_> {
         if capture && !self.focused {
             return;
         }
-        if capture {
-            // The inventory's screens are behind us: no drag survives them.
-            self.reset_inventory_clicks();
-        } else {
+        // The container screen's press state belongs to the screen: a screen
+        // that takes the pointer over starts with its own state, as
+        // `AbstractContainerScreen` does, so a press whose release never
+        // arrived (the pointer left the window) cannot wedge the next
+        // screen's quick move and clicks.
+        self.reset_inventory_clicks();
+        if !capture {
             self.stop_mining();
         }
         // The real pointer takes over from an agent's.
@@ -4946,7 +5416,7 @@ impl Game<'_> {
             self.capture(true);
         }
     }
-    fn draw_item(&mut self, batch: &mut HudBatch, stack: &ItemStack, x: f32, y: f32) {
+    fn draw_item(&self, batch: &mut HudBatch, stack: &ItemStack, x: f32, y: f32) {
         // `GuiGraphics.renderItem`: the resolved item model (tints, foil and
         // special renderers included), then the decorations.
         self.draw_item_model(batch, stack, x, y);
@@ -5036,7 +5506,7 @@ impl Game<'_> {
     /// `GuiGraphicsExtractor.itemDecorations`: the count (or `count_text`)
     /// and damage bar.
     fn draw_item_decorations(
-        &mut self,
+        &self,
         batch: &mut HudBatch,
         stack: &ItemStack,
         x: f32,
@@ -5080,6 +5550,7 @@ impl Game<'_> {
         };
         self.draw_dialog(&mut batch);
         self.draw_pack_prompt(&mut batch);
+        self.draw_link_prompt(&mut batch);
         // Gui.extractRenderState: the debug overlay comes after the screen
         // and the toasts, so it is over everything, menus included.
         self.draw_debug_overlay(&mut batch, size);
@@ -5141,7 +5612,11 @@ impl Game<'_> {
             let delay = horizon_client::attack_strength::delay(self.main_hand_attack_speed());
             let strength = self.hand_strength.scale(0.0, self.main_hand_attack_speed());
             // The 3D crosshair (F3) takes the 2D one's place.
-            if self.camera_type.first_person() && !spectator && !self.debug_crosshair() {
+            // Hud.extractCrosshair: a spectator only sees it over something to open.
+            if self.camera_type.first_person()
+                && (!spectator || self.spectator_crosshair())
+                && !self.debug_crosshair()
+            {
                 let attack = (indicator == 1).then_some(strength);
                 let full = attack.is_some_and(|a| {
                     hud_layout::full_attack_indicator(a, delay, self.crosshair_living())
@@ -5163,12 +5638,12 @@ impl Game<'_> {
                 for d in &draws {
                     if let hud_layout::GuiDraw::Item { slot, x, y, .. } = *d {
                         let stack = if slot == 40 {
-                            self.offhand.clone()
+                            self.offhand.as_ref()
                         } else {
-                            self.inventory[slot as usize].clone()
+                            self.inventory[slot as usize].as_ref()
                         };
                         if let Some(stack) = stack {
-                            self.draw_item(&mut batch, &stack, x as f32, y as f32);
+                            self.draw_item(&mut batch, stack, x as f32, y as f32);
                         }
                     }
                 }
@@ -5326,9 +5801,13 @@ impl Game<'_> {
             Screen::Advancements => self.draw_advancements(&mut batch),
             Screen::WorldOptions => self.draw_world_options(&mut batch),
             Screen::Friends => self.draw_friends_screen(&mut batch),
+            Screen::ServerLinks => self.draw_server_links(&mut batch),
+            Screen::ConfirmLink => self.draw_confirm_link(&mut batch),
+            Screen::DialogWarning => self.draw_dialog_warning(&mut batch),
             Screen::CommandBlock => self.draw_command_block(&mut batch),
             Screen::Inventory => {
                 self.draw_inventory(&mut batch);
+                self.draw_mod_browser(&mut batch);
             }
             Screen::Creative => {
                 self.draw_creative(&mut batch);
@@ -5337,6 +5816,7 @@ impl Game<'_> {
             Screen::Mod => self.draw_mod_screen(&mut batch),
             Screen::Playing | Screen::Options | Screen::Win => {}
         }
+        self.draw_saving_indicator(&mut batch);
         self.draw_toasts(&mut batch);
         self.draw_pack_toasts(&mut batch);
         self.remote_hud(&mut batch);
@@ -5393,7 +5873,9 @@ impl Game<'_> {
                 | BlockEntity::Vault(_)
                 | BlockEntity::Beehive(_)
                 | BlockEntity::CommandBlock(_)
+                | BlockEntity::EndGateway(_)
                 | BlockEntity::Skull(_)
+                | BlockEntity::DaylightDetector
                 | BlockEntity::Campfire(_),
             ) => {}
             None => {
@@ -5664,7 +6146,9 @@ impl Game<'_> {
                     | BlockEntity::Vault(_)
                     | BlockEntity::Beehive(_)
                     | BlockEntity::CommandBlock(_)
+                    | BlockEntity::EndGateway(_)
                     | BlockEntity::Skull(_)
+                    | BlockEntity::DaylightDetector
                     | BlockEntity::Campfire(_),
                 ) => {}
                 None if self.mount_active() => self.draw_mount_background(batch, ox, oy),
@@ -5709,16 +6193,19 @@ impl Game<'_> {
         }
     }
     /// `AbstractContainerScreen` keeps `isQuickCrafting` and the drag it
-    /// belongs to on the screen; Horizon keeps them on the game, so they are
-    /// dropped when a screen closes. A press whose release never reaches the
-    /// screen (the pointer left the window, or the screen closed first) would
+    /// belongs to on the screen. Horizon keeps both on `Game` (`inv_clicks`,
+    /// `inv_drag`, `last_inv_click`), so they are dropped when the pointer
+    /// changes hands: a screen that opens or closes starts with its own
+    /// state, and a press whose release never reached the screen -- the
+    /// pointer left the window, or the screen closed first -- would
     /// otherwise leave every later press on every later screen swallowed.
     pub(super) fn reset_inventory_clicks(&mut self) {
-        self.inv_clicks = Default::default();
+        self.inv_clicks.cancel_drag();
         self.inv_drag = None;
         self.last_inv_click = None;
     }
     pub(super) fn close_container(&mut self) {
+        self.mod_browser_closed();
         self.reset_inventory_clicks();
         self.close_station();
         self.mount_closed();
@@ -5732,7 +6219,8 @@ impl Game<'_> {
             if let Some(rest) = self.give(stack)
                 && let Some(eye) = self.eye_position()
             {
-                self.spawn_item(rest, [eye[0], eye[1] - 0.3, eye[2]], [0.0, 0.1, 0.0], 40);
+                // AbstractContainerMenu.dropOrPlaceInInventory: `drop(stack, false)`.
+                self.throw_from_eyes(rest, eye, false);
             }
         }
         self.craft_size = 2;
@@ -5740,41 +6228,15 @@ impl Game<'_> {
         if let Some(key) = self.container.take() {
             // A cart's or chest boat's items go back to it.
             self.close_cart_container(key);
-            self.container_opener_event(key, false);
+            let last = self.container_opener_event(key, false);
             self.post_block_game_event(
                 "minecraft:container_close",
                 [key.0, key.1, key.2],
                 Some(horizon_client::mobs::Who::Player),
                 None,
             );
-            let name = self
-                .res
-                .facts()
-                .get(self.world.block(key.0, key.1, key.2))
-                .name
-                .clone();
-            let sound = if storage::is_shulker_box(&name) {
-                Some("minecraft:block.shulker_box.close")
-            } else if &*name == "minecraft:ender_chest" {
-                Some("minecraft:block.ender_chest.close")
-            } else if name.contains("chest") {
-                Some("minecraft:block.chest.close")
-            } else if &*name == "minecraft:barrel" {
-                Some("minecraft:block.barrel.close")
-            } else {
-                None
-            };
-            if let Some(sound) = sound {
-                self.audio.play(
-                    sound,
-                    Some([
-                        f64::from(key.0) + 0.5,
-                        f64::from(key.1) + 0.5,
-                        f64::from(key.2) + 0.5,
-                    ]),
-                    0.5,
-                    1.0,
-                );
+            if last {
+                self.container_edge_sound(key, false);
             }
             self.world.modified.insert((key.0 >> 4, key.2 >> 4));
         }
@@ -5833,6 +6295,12 @@ impl Game<'_> {
     /// Several clicks on one menu instance (a quick craft drag is three).
     fn menu_ops(&mut self, ops: &[(Option<usize>, i32, horizon_client::menu::Input)]) -> bool {
         use horizon_client::menu::Input;
+        // BundleMouseActions.onSlotClicked: a Shift click or a swap clears the bundle's selection.
+        for &(slot, _, input) in ops {
+            if let (Some(slot), Input::QuickMove | Input::Swap) = (slot, input) {
+                self.unselect_bundle(slot);
+            }
+        }
         if self.remote.is_some() && self.screen == Screen::Inventory {
             // On a server the clicks are the server's: predicted and sent.
             return self.remote_menu_ops(ops);
@@ -6288,6 +6756,7 @@ impl Game<'_> {
             self.player_menu_sound(sound);
         }
         let crafted = std::mem::take(&mut menu.crafted);
+        let brewed = std::mem::take(&mut menu.brewed);
         let equipped = std::mem::take(&mut menu.equipped);
         for (i, stack) in after.into_iter().enumerate() {
             if let Some(g) = game_of[i] {
@@ -6303,6 +6772,9 @@ impl Game<'_> {
                 self.player_drop(stack);
             }
             self.award_crafted(&crafted);
+            for stack in &brewed {
+                self.trigger_brewed_potion(stack);
+            }
             if furnace_before > furnace_after
                 && self.remote.is_none()
                 && let (Some(pos), Some(p)) = (self.container, self.player.as_ref())
@@ -6445,6 +6917,9 @@ impl Game<'_> {
     fn inventory_press(&mut self, right: bool) {
         use horizon_client::container_screen::Target;
         use horizon_client::menu::Input;
+        if self.mod_browser_press(right) {
+            return;
+        }
         if !right && self.sort_press() {
             return;
         }
@@ -6628,24 +7103,8 @@ impl Game<'_> {
     }
     /// `hasClickedOutside` of the open screen at the cursor.
     fn clicked_outside(&self, batch: &HudBatch) -> bool {
-        use horizon_client::container_screen::{Book, Image, clicked_outside};
-        let (ox, oy) = self.inventory_origin(batch);
-        let (shift, width, height) = if self.screen == Screen::Creative {
-            (0.0, Creative::WIDTH as i32, Creative::HEIGHT as i32)
-        } else {
-            let (shift, width) = match self.station.as_ref().map(|s| s.kind) {
-                Some(stations::Kind::Merchant) => (-50.0, 276),
-                Some(stations::Kind::Beacon) => (beacon::SHIFT, 230),
-                _ => (0.0, 176),
-            };
-            (shift, width, self.screen_height() as i32)
-        };
-        let image = Image {
-            left: (ox + shift) as i32,
-            top: oy as i32,
-            width,
-            height,
-        };
+        use horizon_client::container_screen::{Book, clicked_outside};
+        let image = self.container_image(batch);
         let book = self
             .recipe_book_area(batch)
             .map(|(visible, tab_hovered)| Book {
@@ -6659,6 +7118,26 @@ impl Game<'_> {
             book,
         )
     }
+    /// The open container screen's window: its place and size.
+    fn container_image(&self, batch: &HudBatch) -> horizon_client::container_screen::Image {
+        let (ox, oy) = self.inventory_origin(batch);
+        let (shift, width, height) = if self.screen == Screen::Creative {
+            (0.0, Creative::WIDTH as i32, Creative::HEIGHT as i32)
+        } else {
+            let (shift, width) = match self.station.as_ref().map(|s| s.kind) {
+                Some(stations::Kind::Merchant) => (-50.0, 276),
+                Some(stations::Kind::Beacon) => (beacon::SHIFT, 230),
+                _ => (0.0, 176),
+            };
+            (shift, width, self.screen_height() as i32)
+        };
+        horizon_client::container_screen::Image {
+            left: (ox + shift) as i32,
+            top: oy as i32,
+            width,
+            height,
+        }
+    }
     /// A click outside the window (slot id -999): `THROW` does nothing; a
     /// `PICKUP` drops the carried stack (left) or one of it (right), thrown
     /// from the hand (`AbstractContainerMenu.doClick`, `LivingEntity.drop`).
@@ -6819,7 +7298,7 @@ impl Game<'_> {
         }
     }
     fn click_inventory(&mut self, right: bool) {
-        if self.mount_click(right) {
+        if self.mod_browser_press(right) || self.mount_click(right) {
             return;
         }
         if self.recipe_book_click(right) {
@@ -7151,7 +7630,12 @@ impl Game<'_> {
         self.see_through_vertices = see_through;
         // Entity shadows (EntityRenderer.extractShadow).
         self.mark_translucent_entity(out.len(), "minecraft:entity_shadow");
-        if let Some(sprite) = self.gui.atlas.sprites.get("misc/shadow").copied() {
+        let shadow_sprite = self
+            .settings
+            .entity_shadows
+            .then(|| self.gui.atlas.sprites.get("misc/shadow").copied())
+            .flatten();
+        if let Some(sprite) = shadow_sprite {
             let ambient = if self.dim == Dim::Nether { 0.1 } else { 0.0 };
             let darken = self.sky_darken();
             let a = alpha;
@@ -7329,6 +7813,8 @@ impl Game<'_> {
                         layer: 0,
                         color,
                         light: packed,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
@@ -7550,7 +8036,7 @@ impl Game<'_> {
     /// strength and whether it is a critical hit): the weapon and effects
     /// scaled by the attack strength, a mace's smash, the critical hit, then
     /// enchantments.
-    pub(super) fn melee_damage(&mut self, target_kind: &str) -> (f32, f32, bool) {
+    pub(super) fn melee_damage(&mut self, target_kind: &str) -> (f32, f32, bool, bool) {
         let hand_damage = 1.0 + self.attack_item_info().map_or(0.0, |i| i.attack_damage);
         // Riptide's spin replaces the attack damage attribute.
         let spin = self.player.as_ref().map_or(0.0, |p| p.auto_spin_attack_dmg);
@@ -7578,8 +8064,9 @@ impl Game<'_> {
             amount *= 1.5;
         }
         // Enchantment damage (sharpness, smite, bane) scaled by the attack strength.
-        amount += self.enchant_damage_bonus(target_kind) * scale;
-        (amount, scale, crit)
+        let magic_boost = self.enchant_damage_bonus(target_kind) * scale;
+        amount += magic_boost;
+        (amount, scale, crit, magic_boost > 0.0)
     }
     /// `Player.getAttackStrengthScale(0.5)`.
     fn attack_strength_scale(&self) -> f32 {
@@ -7609,16 +8096,81 @@ impl Game<'_> {
     }
     /// The visual and sound part of `Player.doSweepAttack` after a successful hit.
     pub(super) fn sweep_attack(&mut self, at: [f64; 3], from: Option<[f64; 3]>) {
-        self.particles.add(
-            &horizon_client::particles::ParticleOptions::simple(
-                horizon_client::particles::ParticleType::SweepAttack,
-            ),
-            at,
-            [0.0; 3],
+        let sweep = horizon_client::particles::ParticleOptions::simple(
+            horizon_client::particles::ParticleType::SweepAttack,
         );
+        self.particles.add(&sweep, at, [0.0; 3]);
+        // Player.sweepAttack's `sendParticles(SWEEP_ATTACK, ..., 0, dx, 0, dz, 0)`:
+        // the offset is the one from the player to the particle.
+        let origin = from.unwrap_or(at);
+        let spread = [at[0] - origin[0], 0.0, at[2] - origin[2]];
+        self.lan_send_particles(&sweep, at, spread, 0.0, 0);
         self.audio
             .play("minecraft:entity.player.attack.sweep", from, 1.0, 1.0);
     }
+    /// The damage and knockback part of `Player.doSweepAttack` after a sweep
+    /// hit on the mob at `target`: every other living mob in its box grown by
+    /// (1, 0.25, 1) and closer than 3 blocks (`distanceToSqr < 9`, in creative
+    /// too), but the player's allies
+    /// (`isAlliedTo`), takes `1 + sweeping_damage_ratio * baseDamage` with the
+    /// weapon's enchantments, scaled by the attack strength, and is pushed 0.4
+    /// along the player's yaw.
+    pub(super) fn sweep_damage(&mut self, target: usize, scale: f32) {
+        let Some(p) = self.player.as_ref() else {
+            return;
+        };
+        let from = [p.position.x, p.position.y, p.position.z];
+        // `baseDamage` of `Player.attack` before a critical hit (a sweep has
+        // none) and the enchantments: the attack damage attribute with the
+        // strength and weakness effects, scaled by the attack strength.
+        let hand_damage = 1.0 + self.attack_item_info().map_or(0.0, |i| i.attack_damage);
+        let base_damage = (hand_damage + self.effect_attack_bonus()) * (0.2 + scale * scale * 0.8);
+        // The enchantment's attribute modifier on the attribute's 0 to 1 range.
+        let ratio = self
+            .res
+            .stations()
+            .enchantments
+            .attribute_add(
+                self.inventory[self.selected].as_ref(),
+                "minecraft:sweeping_damage_ratio",
+            )
+            .clamp(0.0, 1.0) as f32;
+        let sweep_damage = 1.0 + ratio * base_damage;
+        let hit_box = self.mobs[target]
+            .bounds()
+            .inflate(horizon_core::geometry::Vec3::new(1.0, 0.25, 1.0));
+        let (uuid, allies) = (
+            self.level.player_uuid.or(Some([0, 0, 0, 1])),
+            self.player_allies(),
+        );
+        let nearby: Vec<usize> = self
+            .mobs
+            .iter()
+            .enumerate()
+            .filter(|(i, m)| {
+                *i != target
+                    && m.alive()
+                    && !m.removed
+                    && !allies.contains(&m.id)
+                    && !mace::ally_of_player(m, uuid)
+                    && m.bounds().intersects(hit_box)
+                    && m.position.distance_squared(p.position) < 9.0
+            })
+            .map(|(i, _)| i)
+            .collect();
+        let (xd, zd) = self.extra_knockback_direction();
+        for i in nearby {
+            let kind = self.mobs[i].kind.id.clone();
+            let kind = format!("minecraft:{}", kind.trim_start_matches("minecraft:"));
+            let damage = (sweep_damage + self.enchant_damage_bonus(&kind)) * scale;
+            let source = self.attack_source(from);
+            if self.hurt_by_player(i, damage, source) {
+                self.mobs[i].knockback(0.4, xd, zd);
+                self.last_hurt_by_player
+                    .insert(self.mobs[i].id, self.lan_acting);
+            }
+        }
+    }
     /// `Player.attack`'s sounds when a vehicle takes the hit (it always does,
     /// and can't be hit critically): knockback when sprinting at full
     /// strength, then strong or weak. Before `swing_arm` resets the charge.
@@ -7703,15 +8255,10 @@ impl Game<'_> {
     pub(super) fn attack_mob(&mut self, index: usize) {
         let target_kind = self.mobs[index].kind.id.clone();
         let target_kind = format!("minecraft:{}", target_kind.trim_start_matches("minecraft:"));
-        let (amount, scale, crit) = self.melee_damage(&target_kind);
+        let (amount, scale, crit, magic) = self.melee_damage(&target_kind);
         let sweep = self.sweep_attack_position(scale, crit);
         let (knockback, knockback_attack) = self.extra_knockback(&target_kind, scale);
         self.attack_ticks = 0;
-        if let Some(p) = self.player.as_mut()
-            && !self.creative
-        {
-            p.cause_food_exhaustion(0.1);
-        }
         let player = self.player.as_ref();
         let from = player.map(|p| [p.position.x, p.position.y, p.position.z]);
         if knockback_attack {
@@ -7726,6 +8273,15 @@ impl Game<'_> {
             None => horizon_client::mobs::Damage::of(horizon_client::mobs::DamageKind::Generic),
         };
         let landed = self.hurt_by_player(index, amount, source);
+        if landed {
+            let victim = self.mob_entity(&self.mobs[index]);
+            self.player_hit(
+                &victim,
+                creatures::damage_type(source.kind, true),
+                None,
+                amount,
+            );
+        }
         if let Some(p) = self.player.as_mut() {
             if p.attack_log.len() >= 64 {
                 p.attack_log.remove(0);
@@ -7766,6 +8322,18 @@ impl Game<'_> {
                     feet,
                     width,
                     height,
+                    false,
+                );
+            }
+            // Player.attackVisualEffects: magicCrit when the enchantments added damage.
+            if magic {
+                self.critical_hit(
+                    self.lan_acting,
+                    self.mobs[index].id as i32,
+                    feet,
+                    width,
+                    height,
+                    true,
                 );
             }
             if actual > 2.0 {
@@ -7779,6 +8347,14 @@ impl Game<'_> {
                     0.2,
                     (actual * 0.5) as u32,
                 );
+                // The players a server serves are sent them too.
+                self.lan_send_particles(
+                    &indicator,
+                    [feet[0], feet[1] + height * 0.5, feet[2]],
+                    [0.1, 0.0, 0.1],
+                    0.2,
+                    (actual * 0.5) as u32,
+                );
             }
             self.last_hurt_by_player
                 .insert(self.mobs[index].id, self.lan_acting);
@@ -7792,34 +8368,57 @@ impl Game<'_> {
             // Player.playServerSideSound: at the player.
             if let Some(at) = sweep {
                 self.sweep_attack(at, from);
+                self.sweep_damage(index, scale);
             } else {
                 self.audio.play(sound, from, 1.0, 1.0);
             }
             // The hurt or death sound the mob raised (getHurtSound / getDeathSound,
             // its voice pitch from its own random).
             let queued = std::mem::take(&mut self.mobs[index].outbox);
+            let mut infested = false;
             for event in queued {
-                if let horizon_client::mobs::MobEvent::Sound(s, at, volume, pitch) = event {
-                    self.audio
-                        .play(&format!("minecraft:{s}"), Some(at), volume, pitch);
+                match event {
+                    horizon_client::mobs::MobEvent::Sound(s, at, volume, pitch) => {
+                        self.audio
+                            .play(&format!("minecraft:{s}"), Some(at), volume, pitch);
+                    }
+                    horizon_client::mobs::MobEvent::Infested { .. } => infested = true,
+                    other => {
+                        // Left for the end of the tick.
+                        self.mobs[index].outbox.push(other);
+                    }
                 }
             }
+            if infested {
+                let id = self.mobs[index].id;
+                self.mob_infested(id);
+            }
             self.weapon_hit(index);
+            // Player.attack: causeFoodExhaustion(0.1F) only when the hit hurt
+            // (inside `if (wasHurt)`), after damageStatsAndHearts.
+            if let Some(p) = self.player.as_mut()
+                && !self.creative
+            {
+                p.cause_food_exhaustion(0.1);
+            }
         } else {
             self.audio
                 .play("minecraft:entity.player.attack.nodamage", from, 1.0, 1.0);
         }
     }
     /// ServerExplosion: rays from a 16^3 grid lose (resistance + 0.3) * 0.3 per step.
-    /// A mob explosion (`Level.ExplosionInteraction.MOB`: drop decay with the
-    /// default mobGriefing rule).
+    /// A mob explosion (`ServerLevel.explode` with `ExplosionInteraction.MOB`:
+    /// blocks are kept without mobGriefing, else the mob_explosion_drop_decay
+    /// rule picks decay).
     fn explode(&mut self, center: [f64; 3], radius: f32) -> Result<()> {
-        self.server_explode(
-            center,
-            radius,
-            explosion::BlockInteraction::DestroyWithDecay,
-            false,
-        )
+        let interaction = if !self.ui.rules.bool("mob_griefing") {
+            explosion::BlockInteraction::Keep
+        } else if self.ui.rules.bool("mob_explosion_drop_decay") {
+            explosion::BlockInteraction::DestroyWithDecay
+        } else {
+            explosion::BlockInteraction::Destroy
+        };
+        self.server_explode(center, radius, interaction, false)
     }
     /// Copies of a save batch carrying its live block entities and save data.
     fn with_entities<'a>(
@@ -7881,6 +8480,8 @@ impl Game<'_> {
                     layer: 2,
                     color,
                     light: 0,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         };
@@ -7921,6 +8522,7 @@ impl Game<'_> {
         creative: bool,
         create: Option<&horizon_client::title::WorldOptions>,
     ) -> Result<()> {
+        world_loading::world_data_used();
         if self.defer_world_entry(PendingWorldEntry::Local {
             folder: folder.to_owned(),
             name: name.map(str::to_owned),
@@ -7986,6 +8588,7 @@ impl Game<'_> {
         );
         self.session_lock = Some(session_lock);
         self.end.set_locator(locator);
+        self.share_spawn_conditions();
         self.score = Default::default();
         self.fns = Default::default();
         self.bosses = Default::default();
@@ -8124,6 +8727,7 @@ impl Game<'_> {
             seed,
         )?;
         self.end.set_locator(locator);
+        self.share_spawn_conditions();
         Ok((streaming, save))
     }
     /// Change dimension through a portal (Entity.changeDimension with
@@ -8362,6 +8966,10 @@ impl Game<'_> {
         }
         self.lan_close(false);
         self.save_game()?;
+        if let Some(mut remote) = self.remote.take() {
+            // Minecraft.disconnect closes the connection, so the host sees a clean leave.
+            remote.session.disconnect();
+        }
         self.saved_for_exit = true;
         Ok(())
     }
@@ -8473,15 +9081,54 @@ impl Game<'_> {
         }
         self.apply_enchantment_attributes();
     }
-    /// Inventory.hurtArmor: each piece loses max(1, damage / 4) durability.
-    fn hurt_armor(&mut self, damage: f32) {
+    /// The armor hits among a tick's motion events (`Player.hurtArmor` from
+    /// `getDamageAfterArmorAbsorb`), whatever the damage: a mob, an explosion,
+    /// a cactus, lava, a campfire.
+    fn wear_armor(&mut self, events: &[MotionEvent]) {
+        for event in events {
+            if let MotionEvent::Health(horizon_client::health::HealthEvent::ArmorHurt {
+                source,
+                amount,
+            }) = event
+            {
+                self.hurt_armor(*source, *amount);
+            }
+        }
+    }
+    /// `Player.hurtArmor` -> `LivingEntity.doHurtEquipment`: each worn piece that
+    /// wears when its wearer is hurt loses max(1, damage / 4) durability, except
+    /// to a fire source when the piece resists fire (`ItemStack.canBeHurtBy`).
+    fn hurt_armor(&mut self, source: horizon_world::damage_source::DamageTypeId, damage: f32) {
+        if damage <= 0.0 {
+            return;
+        }
         let amount = ((damage / 4.0) as u32).max(1);
+        let name = self
+            .motion
+            .health
+            .damage
+            .definition(source)
+            .map(|d| d.name.clone())
+            .unwrap_or_default();
+        let fire = self
+            .motion
+            .health
+            .damage
+            .in_tag(source, "minecraft:is_fire");
         let mut broke = false;
         let losses: Vec<u32> = (0..4)
-            .map(|i| {
-                self.armor[i]
-                    .clone()
-                    .map_or(amount, |s| self.durability_loss(&s, amount))
+            .map(|i| match self.armor[i].clone() {
+                Some(s)
+                    if self
+                        .res
+                        .items()
+                        .get(&s.item)
+                        .is_some_and(|info| info.equip_damage_on_hurt)
+                        && !(fire && self.res.items().resists_fire(&s, &name)) =>
+                {
+                    self.durability_loss(&s, amount)
+                }
+                _ => 0,
             })
             .collect();
         for (slot, amount) in self.armor.iter_mut().zip(losses) {
@@ -8578,7 +9225,8 @@ impl Game<'_> {
             }
             fn drop_stack(&mut self, stack: ItemStack) {
                 if let Some(eye) = self.0.eye_position() {
-                    self.0.spawn_item(stack, eye, [0.0, 0.1, 0.0], 40);
+                    // ItemUtils.createFilledResult: `player.drop(stack, false)`.
+                    self.0.throw_from_eyes(stack, eye, false);
                 }
             }
         }
@@ -8603,6 +9251,9 @@ impl Game<'_> {
         if result.outcome == Outcome::Pass {
             return Ok(false);
         }
+        if let Some(stat) = result.stat {
+            self.stats.custom(stat, 1);
+        }
         if let Some(block) = result.block
             && let Ok(new) = registry.resolve(&block)
         {
@@ -8712,6 +9363,8 @@ impl Game<'_> {
         else {
             return Ok(false);
         };
+        // BlockTransformer.transformBlock: ITEM_USED_ON_BLOCK before the swap.
+        self.trigger_block("minecraft:item_used_on_block", pos, stack);
         self.level_set(pos, new)?;
         // BlockTransformer.TransformParticle.send.
         self.transform_particle(&particle, pos);
@@ -8816,6 +9469,24 @@ impl Game<'_> {
             }
         }
     }
+    /// `ItemStack.hurtWithoutBreaking`: Unbreaking applies, but the stack stops at
+    /// one point of durability left instead of breaking.
+    fn hurt_held_without_breaking(&mut self, amount: u32) {
+        if self.creative {
+            return;
+        }
+        let Some(held) = self.held().cloned() else {
+            return;
+        };
+        let amount = self.durability_loss(&held, amount);
+        let max = self.res.items().get(&held.item).map_or(0, |i| i.max_damage);
+        if amount == 0 || max == 0 {
+            return;
+        }
+        if let Some(stack) = self.held_mut().as_mut() {
+            stack.damage = (stack.damage + amount).min(max - 1);
+        }
+    }
     /// Block tool use: distinguish success, failure and fall-through for hand feedback.
     fn use_tool(
         &mut self,
@@ -8903,7 +9574,8 @@ impl Game<'_> {
                 } else if let Some(rest) = self.give(filled)
                     && let Some(eye) = self.eye_position()
                 {
-                    self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40);
+                    // ItemUtils.createFilledResult: `player.drop(stack, false)`.
+                    self.throw_from_eyes(rest, eye, false);
                 }
             }
             return Ok(UseResult::Success { swing: true });
@@ -8965,6 +9637,8 @@ impl Game<'_> {
             if let Some(waxed) = old.and_then(|old| self.res.transformers().waxed(registry, &old))
                 && let Ok(state) = registry.resolve(&waxed)
             {
+                // HoneycombItem.useOn: ITEM_USED_ON_BLOCK before the swap.
+                self.trigger_block("minecraft:item_used_on_block", hit.pos, stack);
                 self.level_set(hit.pos, state)?;
                 self.level_event_at(3003, hit.pos, 0);
                 self.audio.play(
@@ -9053,8 +9727,29 @@ impl Game<'_> {
         while value > 0 {
             let v = ExperienceOrb::split(value);
             value -= v;
-            let _merge_id = self.world.random.next_int_bound(40);
-            self.add_orb(at, v);
+            let merge_id = self.world.random.next_int_bound(40).unwrap_or(0);
+            self.award_orb(at, v, merge_id);
+        }
+    }
+    /// `ExperienceOrb.tryMergeToExisting`: an orb of the same value within a
+    /// 1 block box of `at`, whose id is a multiple of 40 from `merge_id`, takes
+    /// the new one as one more in its count (and restarts its age); otherwise
+    /// a fresh orb spawns.
+    fn award_orb(&mut self, at: [f64; 3], value: u32, merge_id: i32) {
+        let centre = Vec3::new(at[0], at[1], at[2]);
+        let half = Vec3::new(0.5, 0.5, 0.5);
+        let area = Aabb::new(centre.subtract(half), centre.add_vector(half));
+        // A server's orbs are its own; a LAN or server guest only shows them.
+        let target = self.remote.is_none().then(|| {
+            self.orbs
+                .iter_mut()
+                .find(|o| o.can_merge(merge_id as u32, value) && o.bounds().intersects(area))
+        });
+        if let Some(Some(orb)) = target {
+            orb.count += 1;
+            orb.age = 0;
+        } else {
+            self.add_orb(at, value);
         }
     }
     /// `new ExperienceOrb(level, pos, Vec3.ZERO, value)`: yaw and motion from
@@ -9076,6 +9771,8 @@ impl Game<'_> {
             value,
             age: 0,
             on_ground: false,
+            count: 1,
+            ticks: 0,
         });
     }
     fn can_place_used_fire(&mut self, target: [i32; 3]) -> bool {
@@ -9152,18 +9849,31 @@ impl Game<'_> {
                     }),
             );
         }
+        // Player.aiStep: the pickup area is the box inflated by (1, 0.5, 1).
         let bounds = player.map(|p| {
             let w = f64::from(p.dimensions.width) / 2.0;
             (
-                [p.position.x - w, p.position.y, p.position.z - w],
                 [
-                    p.position.x + w,
-                    p.position.y + f64::from(p.dimensions.height),
-                    p.position.z + w,
+                    p.position.x - w - 1.0,
+                    p.position.y - 0.5,
+                    p.position.z - w - 1.0,
+                ],
+                [
+                    p.position.x + w + 1.0,
+                    p.position.y + f64::from(p.dimensions.height) + 0.5,
+                    p.position.z + w + 1.0,
                 ],
             )
         });
         let mut orbs = std::mem::take(&mut self.orbs);
+        // An orb has no random of its own here: lava draws from one made on
+        // first use, apart from the level stream.
+        let mut lava_random = None;
+        let mut next_float = || {
+            lava_random
+                .get_or_insert_with(dispenser::entity_random)
+                .next_float()
+        };
         orbs.retain_mut(|o| {
             let distance = |feet: &[f64; 3]| -> f64 {
                 (feet[0] - o.position.x).powi(2)
@@ -9175,12 +9885,22 @@ impl Game<'_> {
                 .filter(|(feet, _)| distance(feet) < 64.0)
                 .min_by(|a, b| distance(&a.0).total_cmp(&distance(&b.0)))
                 .map(|(_, target)| *target);
-            o.tick(&self.world, self.res.facts(), self.collision, target)
+            o.tick(
+                &self.world,
+                self.res.facts(),
+                self.collision,
+                target,
+                &mut next_float,
+            )
         });
+        // ExperienceOrb.scanForMerges runs on the server only.
+        if self.remote.is_none() {
+            horizon_client::entities::merge_orbs(&mut orbs);
+        }
         let mut gained = 0;
         let mut taken = Vec::new();
         if let Some((min, max)) = bounds {
-            orbs.retain(|o| {
+            orbs.retain_mut(|o| {
                 let touching = o.position.x + 0.25 > min[0]
                     && o.position.x - 0.25 < max[0]
                     && o.position.y + 0.5 > min[1]
@@ -9188,11 +9908,13 @@ impl Game<'_> {
                     && o.position.z + 0.25 > min[2]
                     && o.position.z - 0.25 < max[2];
                 if touching && self.xp_delay == 0 {
-                    // ExperienceOrb.playerTouch: one orb every 2 ticks.
+                    // ExperienceOrb.playerTouch: one orb every 2 ticks; a
+                    // merged orb gives its value once per count.
                     self.xp_delay = 2;
                     gained += o.value;
                     taken.push(o.clone());
-                    return false;
+                    o.count -= 1;
+                    return o.count > 0;
                 }
                 true
             });
@@ -9238,16 +9960,13 @@ impl Game<'_> {
     /// sound every fifth level (at most every 100 ticks).
     pub(super) fn give_orb_points(&mut self, gained: u32) {
         let at = self.eye_position();
-        if self.experience.give(gained as i32)
-            && self.experience.level % 5 == 0
+        // Player.giveExperienceLevels runs per level, so the first multiple of 5
+        // crossed plays the sound (and starts the cooldown for the rest).
+        if let Some(level) = self.experience.give(gained as i32)
             && self.ticks > self.last_level_up + 100
         {
             self.last_level_up = self.ticks;
-            let volume = if self.experience.level > 30 {
-                1.0
-            } else {
-                self.experience.level as f32 / 30.0
-            };
+            let volume = if level > 30 { 1.0 } else { level as f32 / 30.0 };
             self.audio
                 .play("minecraft:entity.player.levelup", at, volume * 0.75, 1.0);
         }
@@ -9268,7 +9987,10 @@ impl Game<'_> {
         };
         // BowItem.shootProjectile: shootFromRotation(power * 3, inaccuracy 1).
         let p = Vec3::new(eye[0], eye[1] - 0.1, eye[2]);
-        let (power_bonus, infinity) = self.bow_enchantments();
+        let ammo = arrow_slot
+            .and_then(|i| self.stack_in(i).cloned())
+            .unwrap_or_else(|| ItemStack::new("minecraft:arrow", 1));
+        let (power_bonus, infinity) = self.bow_enchantments(&ammo.item);
         let kind = horizon_client::projectiles::ProjectileKind::Arrow {
             base_damage: 2.0 + power_bonus,
             critical: power >= 1.0,
@@ -9282,9 +10004,6 @@ impl Game<'_> {
         // ProjectileWeaponItem.useAmmo: creative and Infinity draw without
         // using the ammo, so the arrow is CREATIVE_ONLY; else setOwner(player)
         // lets it be picked up.
-        let ammo = arrow_slot
-            .and_then(|i| self.stack_in(i).cloned())
-            .unwrap_or_else(|| ItemStack::new("minecraft:arrow", 1));
         if let Some(a) = arrow.arrow.as_mut() {
             a.set_item(&horizon_client::arrows::drawn_ammo(
                 &ammo,
@@ -9312,7 +10031,7 @@ impl Game<'_> {
             velocity,
             on_ground,
         );
-        self.creatures.projectiles.push(arrow);
+        self.add_projectile(arrow);
         self.player_projectile_shot();
         let pitch = 1.0 / (self.world.random.next_float() * 0.4 + 1.2) + power * 0.5;
         self.audio
@@ -9617,6 +10336,14 @@ impl Game<'_> {
         };
         Some(t < 0.15)
     }
+    /// `Level.isRainingAt`: it rains, the sky light is 15, nothing that stops
+    /// motion is above, and the biome's precipitation there is rain.
+    fn raining_at(&self, p: BlockPos) -> bool {
+        self.world.weather.levels(1.0).0 > 0.2
+            && self.world.light(p.x, p.y, p.z) >> 4 == 15
+            && self.rain_height(p.x, p.z) <= p.y
+            && self.precipitation(p.x, p.y, p.z) == Some(false)
+    }
     /// `getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)`: one above the
     /// highest block in `blocks_motion_in_heightmap` or holding a fluid.
     fn rain_height(&self, x: i32, z: i32) -> i32 {
@@ -9630,37 +10357,7 @@ impl Game<'_> {
         if self.flash > 0 {
             self.flash -= 1;
         }
-        let (rain, _) = self.world.weather.levels(1.0);
-        let Some(eye) = self.eye_position() else {
-            return;
-        };
-        // WeatherEffectRenderer.tickRainParticles: occasional rain sounds.
-        if rain > 0.0 && self.world.random.next_int_bound(3).unwrap_or(1) < (rain * 3.0) as i32 {
-            let r = &mut self.world.random;
-            let (dx, dz) = (
-                r.next_int_bound(21).unwrap_or(10) - 10,
-                r.next_int_bound(21).unwrap_or(10) - 10,
-            );
-            let (x, z) = (eye[0].floor() as i32 + dx, eye[2].floor() as i32 + dz);
-            let top = self.rain_height(x, z);
-            if self.precipitation(x, top, z) == Some(false)
-                && (top - eye[1] as i32).abs() < 10
-                && self.world.random.next_int_bound(5).unwrap_or(1) == 0
-            {
-                let above = f64::from(top) > eye[1] + 1.0;
-                let (name, volume, pitch) = if above {
-                    ("minecraft:weather.rain.above", 0.1, 0.5)
-                } else {
-                    ("minecraft:weather.rain", 0.2, 1.0)
-                };
-                self.audio.play(
-                    name,
-                    Some([f64::from(x) + 0.5, f64::from(top), f64::from(z) + 0.5]),
-                    volume,
-                    pitch,
-                );
-            }
-        }
+        // The rain sounds come with the rain splashes (`tick_particles`).
     }
     /// WeatherEffectRenderer: rain and snow columns within the weather radius.
     fn weather_geometry(
@@ -10201,6 +10898,9 @@ impl Game<'_> {
         let level = &mut self.level;
         level.creative = self.creative;
         level.game_mode = mode;
+        // PrimaryLevelData.setDifficulty: /difficulty and the options button change it.
+        level.difficulty =
+            horizon_client::title::DIFFICULTIES[usize::from(self.ui.difficulty) & 3].into();
         level.time = self.world.game_time;
         level.weather = self.world.weather;
         level.day_time = self.world.day_time;
@@ -10356,6 +11056,21 @@ impl Game<'_> {
             }
             return Ok(false);
         }
+        // A server pack's reload covers the frame with its progress
+        // (`LoadingOverlay`) until `tick_server_packs` applies it.
+        if let Some(reload) = &self.server_packs.reload {
+            if let Some(renderer) = &mut self.renderer {
+                let mut hud = HudBatch::new([renderer.config.width, renderer.config.height]);
+                horizon_client::level_loading::draw_progress(
+                    &mut hud,
+                    &self.gui.atlas,
+                    reload.progress.line(),
+                    reload.progress.fraction(),
+                );
+                return renderer.render(&loading_frame(&hud));
+            }
+            return Ok(false);
+        }
         let Some(size) = self
             .renderer
             .as_ref()
@@ -10476,7 +11191,11 @@ impl Game<'_> {
         let debug_crosshair = horizon_client::gizmos::camera_relative(&crosshair.on_top, at, view);
         // LevelExtractor.extractBlockOutline: model translucency controls draw order.
         let mut outline_after_terrain = false;
-        let outline = if self.screen == Screen::Playing && !self.spectator() {
+        // GameRenderer.shouldRenderBlockOutline: not with the HUD hidden (F1), and only for a
+        // player who may build. Adventure players only get one with a CAN_BREAK or
+        // CAN_PLACE_ON item and spectators with a menu block; Horizon reads neither the
+        // components nor opens menus for spectators, so those never show it.
+        let outline = if self.screen == Screen::Playing && !self.ui.hide_gui && self.may_build() {
             self.pick()
                 .map(|h| {
                     let state = self.world.block(h.pos[0], h.pos[1], h.pos[2]);
@@ -10501,6 +11220,17 @@ impl Game<'_> {
                         [0.0; 3]
                     };
                     let p = h.pos.map(f64::from);
+                    if let Some(b) = self.context_outline(h.pos, state) {
+                        return horizon_client::blocks::cube_edges()
+                            .iter()
+                            .map(|e| {
+                                std::array::from_fn(|i| {
+                                    let k = i % 3;
+                                    p[k] + b[k] + e[i] * (b[k + 3] - b[k])
+                                })
+                            })
+                            .collect();
+                    }
                     f.outline_edges
                         .iter()
                         .map(|e| std::array::from_fn(|i| p[i % 3] + o[i % 3] + e[i]))
@@ -10550,6 +11280,7 @@ impl Game<'_> {
         let mut entities = std::mem::take(&mut self.entity_vertices);
         entities.clear();
         self.see_through_vertices.clear();
+        self.glowing_vertices.get_mut().clear();
         if !title {
             entities = horizon_client::spans::time("entity_geometry", || {
                 self.entity_geometry(camera, alpha, entities)
@@ -10617,6 +11348,7 @@ impl Game<'_> {
         // map_patches any earlier leaves them a frame behind.
         hud.patches.append(&mut self.map_patches);
         let entity_spans = std::mem::take(self.entity_spans.get_mut());
+        let glowing = std::mem::take(self.glowing_vertices.get_mut());
         let frame = Frame {
             weather: &weather,
             weather_time: horizon_client::weather::Time::new(self.world.game_time, alpha as f32),
@@ -10661,10 +11393,13 @@ impl Game<'_> {
             dark_disc: self.dark_disc(camera),
             outline,
             outline_after_terrain,
+            outline_high_contrast: self.settings.file.bool("highContrastBlockOutline"),
             debug_lines: &debug_lines,
             debug_lines_on_top: &debug_lines_on_top,
             debug_crosshair: &debug_crosshair,
             hud: &hud,
+            glint_alpha: self.settings.file.double("glintStrength") as f32,
+            glint_ticks: self.glint_ticks(),
             clouds: (!title
                 && self.dim == Dim::Overworld
                 && horizon_client::clouds::visible(&self.settings.clouds, sky.cloud_color[3]))
@@ -10682,6 +11417,7 @@ impl Game<'_> {
             }),
             entities: &entities,
             entity_spans: &entity_spans,
+            glowing: &glowing,
             dynamic_lights: &self.dynamic_lights,
             lightning: horizon_client::gfx::lightning::Input {
                 bolts: &bolts,
@@ -10720,7 +11456,7 @@ impl Game<'_> {
             }),
             ticks: self.ticks,
             darkness: self.darkness_lighting(alpha as f32),
-            night_vision: self.night_vision_intensity(),
+            night_vision: self.night_vision_intensity(alpha as f32),
             block_flicker: self.fog.block_light_flicker,
             boss_darken: self
                 .boss_overlay
@@ -10737,6 +11473,7 @@ impl Game<'_> {
         // Restore storage even when rendering fails (for example, a lost surface).
         self.entity_vertices = entities;
         *self.entity_spans.get_mut() = entity_spans;
+        *self.glowing_vertices.get_mut() = glowing;
         self.see_through_vertices = see_through;
         result
     }
@@ -10892,6 +11629,10 @@ impl Game<'_> {
                 Screen::GameModeSwitcher => self.close_gamemode_switcher(false),
                 Screen::Dead => {}
                 Screen::Stats | Screen::Friends => self.screen = Screen::Paused,
+                Screen::ServerLinks => self.screen = Screen::Paused,
+                // ConfirmScreen.keyPressed: Escape answers no; both return to
+                // the Server Links screen they came from.
+                Screen::ConfirmLink | Screen::DialogWarning => self.screen = Screen::ServerLinks,
                 Screen::Advancements => self.close_advancements(),
                 Screen::WorldOptions => self.world_options_escape(),
                 Screen::CommandBlock => self.close_command_block(),
@@ -10960,8 +11701,10 @@ impl Game<'_> {
             // key.swapOffhand: on a server, ServerboundPlayerActionPacket SWAP_ITEM_WITH_OFFHAND
             // (the server swaps the hands and sends both slots back; spectators can't).
             KeyCode::KeyF if self.screen == Screen::Playing && self.remote.is_some() => {
-                if !self.spectator() {
-                    self.remote_swap_hands();
+                if !self.spectator()
+                    && let Some(r) = self.remote.as_mut()
+                {
+                    r.pending_keys.push(key);
                 }
             }
             KeyCode::KeyF if self.screen == Screen::Playing => {
@@ -11058,11 +11801,28 @@ impl Game<'_> {
         }
         Ok(())
     }
-    /// LOD Distance as far terrain uses it (`Graphics::lod_distance_on`).
+    /// LOD Distance and Far Detail Reduced as chosen: the player's LOD
+    /// Distance when it is on, else a mod's far terrain
+    /// (`render.set-far-terrain`).
+    fn far_terrain_choice(&self) -> (u32, bool) {
+        let g = &self.settings.horizon;
+        let reduced = g.far_detail == horizon_client::graphics::FarDetail::Reduced;
+        if g.lod_distance > 0 {
+            return (g.lod_distance, reduced);
+        }
+        match self.mod_far_terrain() {
+            Some(f) => (f.distance, reduced || f.reduced),
+            None => (0, reduced),
+        }
+    }
+    /// LOD Distance as far terrain uses it (`graphics::lod_distance_capped`).
     fn lod_distance(&self) -> u32 {
+        let (distance, _) = self.far_terrain_choice();
         match &self.renderer {
-            Some(renderer) => self.settings.horizon.lod_distance_on(&renderer.info),
-            None => self.settings.horizon.lod_distance.min(1024),
+            Some(renderer) => {
+                horizon_client::graphics::lod_distance_capped(distance, &renderer.info)
+            }
+            None => distance.min(1024),
         }
     }
     /// Only enabled LOD worlds extend the renderer's range, never simulation.
@@ -11083,7 +11843,7 @@ impl Game<'_> {
         }
     }
     fn prepare_lod(&mut self) {
-        let enabled = self.settings.horizon.lod_distance > 0
+        let enabled = self.far_terrain_choice().0 > 0
             && self.renderer.is_some()
             && self.player.is_some()
             && self.title.is_none()
@@ -11180,6 +11940,7 @@ impl Game<'_> {
         {
             log::warn!("Horizon: failed to save unloaded chunks: {e}");
         }
+        let (far_distance, far_reduced) = self.far_terrain_choice();
         if let Some(renderer) = self.renderer.as_mut() {
             let g = &self.settings.horizon;
             let budgeted = g.chunk_updates > 0 || g.upload_budget_kib > 0;
@@ -11233,12 +11994,10 @@ impl Game<'_> {
             }
             renderer.remove_columns(unloaded.iter().map(|c| (c.x, c.z)));
             if let (Some(lod), Some(player)) = (&mut self.lod, &self.player) {
-                let lod_distance = self.settings.horizon.lod_distance_on(&renderer.info);
+                let lod_distance =
+                    horizon_client::graphics::lod_distance_capped(far_distance, &renderer.info);
                 lod.set_near_loading(self.streaming.busy());
-                lod.set_reduced_detail(
-                    self.settings.horizon.far_detail
-                        == horizon_client::graphics::FarDetail::Reduced,
-                );
+                lod.set_reduced_detail(far_reduced);
                 // The covered columns change only with the complete ones and
                 // the render area: rebuilt then, not every frame.
                 let at = (
@@ -11405,6 +12164,19 @@ impl ApplicationHandler for Game<'_> {
         {
             return;
         }
+        // The pack reload's progress overlay takes no input
+        // (`LoadingOverlay`): `start_pack_reload` released what was held.
+        if self.server_packs.reload.is_some()
+            && !matches!(
+                &event,
+                WindowEvent::CloseRequested
+                    | WindowEvent::Focused(_)
+                    | WindowEvent::Resized(_)
+                    | WindowEvent::RedrawRequested
+            )
+        {
+            return;
+        }
         if self.pending_save.is_some() {
             match event {
                 WindowEvent::CloseRequested => {
@@ -11561,6 +12333,7 @@ impl ApplicationHandler for Game<'_> {
                     }
                     if self.screen == Screen::Inventory
                         && d != 0.0
+                        && !self.bundle_scroll(scaled(raw_x), scaled(raw_y))
                         && !self.tweak_scroll(d, self.inventory_target().0)
                     {
                         self.station_scroll(d);
@@ -11571,10 +12344,18 @@ impl ApplicationHandler for Game<'_> {
                     if self.screen == Screen::WorldOptions && d != 0.0 {
                         self.world_options_scroll(d);
                     }
+                    if self.screen == Screen::ServerLinks && d != 0.0 {
+                        self.server_links_scroll(d);
+                    }
                     if self.screen == Screen::Advancements {
                         self.advancements_scroll(scaled(raw_x) as f32, d);
                     }
                 }
+                WindowEvent::MouseInput { state, button, .. } if self.link_prompt.is_some() => {
+                    if state == ElementState::Pressed && button == MouseButton::Left {
+                        self.link_prompt_click();
+                    }
+                }
                 WindowEvent::MouseInput { state, button, .. }
                     if self.server_packs.prompt.is_some() =>
                 {
@@ -11624,7 +12405,8 @@ impl ApplicationHandler for Game<'_> {
                     let (action, sound) = self.title.as_mut().map_or((Action::None, false), |t| {
                         let clicked = t.click(self.cursor.0, self.cursor.1, (b.width, b.height));
                         t.press_field(atlas, self.cursor, (b.width, b.height), shift);
-                        clicked
+                        let rules = t.press_rules(atlas, self.cursor, (b.width, b.height));
+                        (clicked.0, clicked.1 || rules)
                     });
                     self.save_title_options();
                     if sound {
@@ -11762,6 +12544,15 @@ impl ApplicationHandler for Game<'_> {
                         Screen::WorldOptions if pressed && button == MouseButton::Left => {
                             self.world_options_click()
                         }
+                        Screen::ServerLinks if pressed && button == MouseButton::Left => {
+                            self.server_links_click()?
+                        }
+                        Screen::ConfirmLink if pressed && button == MouseButton::Left => {
+                            self.confirm_link_click()
+                        }
+                        Screen::DialogWarning if pressed && button == MouseButton::Left => {
+                            self.dialog_warning_click()?
+                        }
                         Screen::WorldOptions if button == MouseButton::Left => {
                             self.world_options_release()
                         }
@@ -11794,6 +12585,13 @@ impl ApplicationHandler for Game<'_> {
                     }
                 }
                 // ConfirmScreen.keyPressed: Escape answers no.
+                WindowEvent::KeyboardInput { event, .. } if self.link_prompt.is_some() => {
+                    if event.state == ElementState::Pressed
+                        && event.physical_key == PhysicalKey::Code(KeyCode::Escape)
+                    {
+                        self.answer_link_prompt(false);
+                    }
+                }
                 WindowEvent::KeyboardInput { event, .. } if self.server_packs.prompt.is_some() => {
                     if event.state == ElementState::Pressed
                         && event.physical_key == PhysicalKey::Code(KeyCode::Escape)
@@ -11862,6 +12660,14 @@ impl ApplicationHandler for Game<'_> {
                     // The recipe book's search box takes every key but Escape.
                     self.recipe_key(&event);
                 }
+                WindowEvent::KeyboardInput { event, .. }
+                    if self.mod_browser_typing()
+                        && event.state == ElementState::Pressed
+                        && !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) =>
+                {
+                    // A mod's item panel's search box, as the recipe book's.
+                    self.mod_browser_key(&event);
+                }
                 WindowEvent::KeyboardInput { event, .. }
                     if self.station_typing()
                         && event.state == ElementState::Pressed
@@ -12185,6 +12991,16 @@ impl ApplicationHandler for Game<'_> {
         }
     }
     fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        if horizon_threads::stop_requests() > 0
+            && self.pending_save.as_ref().is_none_or(|save| !save.quit)
+        {
+            // SIGTERM, SIGINT or SIGHUP: the shutdown hook's server halt, as a window close.
+            if let Err(error) = self.begin_closing_save(true) {
+                self.error = Some(error);
+                event_loop.exit();
+                return;
+            }
+        }
         if self.pending_save.is_some() {
             match self.poll_closing_save() {
                 Ok(true) => event_loop.exit(),
@@ -12309,6 +13125,7 @@ impl<'a> Game<'a> {
             world_loader: None,
             pending_pack_reload: false,
             server_packs: Default::default(),
+            link_prompt: None,
             dialogs: Default::default(),
             world_renderer_ready: false,
             collision: res.collision(),
@@ -12342,6 +13159,7 @@ impl<'a> Game<'a> {
             craft_table: None,
             inv_drag: None,
             tweaks: Default::default(),
+            bundle_mouse: Default::default(),
             inv_clicks: Default::default(),
             last_inv_click: None,
             last_quick_moved: None,
@@ -12384,6 +13202,7 @@ impl<'a> Game<'a> {
             luminance: None,
             see_through_vertices: Vec::new(),
             entity_spans: Default::default(),
+            glowing_vertices: Default::default(),
             pack_ids: None,
             health_hud: hud_layout::HealthHud::default(),
             started: now,
@@ -12403,7 +13222,14 @@ impl<'a> Game<'a> {
             level,
             session_lock: None,
             audio,
-            music: Default::default(),
+            music: {
+                // The manager starts with the saved option (MusicManager's constructor).
+                let mut music = horizon_client::music::MusicManager::default();
+                music.frequency = horizon_client::music::MusicFrequency::parse(
+                    &settings.file.name("musicFrequency"),
+                );
+                music
+            },
             ambience: Default::default(),
             sound_paused: false,
             cart_sounds: HashSet::new(),
@@ -12447,6 +13273,8 @@ impl<'a> Game<'a> {
             command_source: None,
             titles: Default::default(),
             tool_highlight: Default::default(),
+            saving_indicator: Default::default(),
+            autosaving: false,
             applied_modifiers: Vec::new(),
             experience: Experience::default(),
             orbs: Vec::new(),
@@ -12465,6 +13293,7 @@ impl<'a> Game<'a> {
             dragging: false,
             avatar: Default::default(),
             flash: 0,
+            rain_sound_time: 0,
             lightning_seen: [0; 2],
             sleeping: None,
             sleep_timer: 0,
@@ -12519,12 +13348,15 @@ impl<'a> Game<'a> {
             dragon_model: prepared.dragon_model,
             map_patches: Vec::new(),
             text_displays: Default::default(),
+            remote_knots: Default::default(),
+            knot_ids: Default::default(),
             text_display_vertices: 0,
             skin_downloads: RefCell::new(horizon_client::skins::Downloader::new(
                 std::env::current_dir()
                     .unwrap_or_default()
                     .join("assets/skins"),
             )),
+            skin_profiles: RefCell::new(horizon_client::skins::Resolver::new()),
             skin_slots: Vec::new(),
             trim_slots: Vec::new(),
             cart_models: prepared.cart_models,
@@ -12591,6 +13423,7 @@ impl<'a> Game<'a> {
             forced_hit: None,
             guest_use: None,
             lan_events: Vec::new(),
+            lan_cushion_breaks: Vec::new(),
             lan_block_events: Vec::new(),
             lan_entity_events: Vec::new(),
             lan_critical_hits: Vec::new(),
@@ -12599,6 +13432,7 @@ impl<'a> Game<'a> {
             lan_acting: None,
             guest_packets: Vec::new(),
             guest_cooldowns: Vec::new(),
+            guest_entity_events: Vec::new(),
             lan_acting_name: None,
             lan_acting_uuid: None,
             chat_capture: None,
@@ -12625,6 +13459,7 @@ impl<'a> Game<'a> {
             restore_player_state: true,
             stats_ui: Default::default(),
             adv_ui: Default::default(),
+            links_ui: Default::default(),
             camera_type: Default::default(),
             fangs: Default::default(),
             player_model: None,
@@ -12770,6 +13605,17 @@ impl Game<'_> {
         if self.rest_loader.is_some() {
             return Ok(());
         }
+        let on_world_screens = self.title.as_ref().is_some_and(|title| {
+            !matches!(
+                title.mode,
+                horizon_client::title::Mode::Main | horizon_client::title::Mode::Multiplayer(_)
+            )
+        });
+        world_loading::preload_world_data(
+            on_world_screens,
+            &self.options.resources,
+            self.pack.assets.registry,
+        );
         if std::mem::take(&mut self.pending_pack_reload) {
             self.reload_packs();
         }
@@ -12856,7 +13702,6 @@ const NUMERIC_KEYS: [KeyCode; 11] = [
     KeyCode::Numpad9,
 ];
 
-const STAGES: u32 = 10;
 const STAGE_LINES: [&str; 10] = [
     "Loading menu",
     "Loading assets",
@@ -12872,19 +13717,28 @@ const STAGE_LINES: [&str; 10] = [
 
 /// The background loader's checkpoint, read by the loading screen each frame.
 #[derive(Clone)]
-struct Progress(Arc<AtomicU32>);
+struct Progress {
+    value: Arc<AtomicU32>,
+    lines: &'static [&'static str],
+}
 impl Progress {
     fn new() -> Self {
-        Self(Arc::new(AtomicU32::new(0)))
+        Self::with(&STAGE_LINES)
+    }
+    fn with(lines: &'static [&'static str]) -> Self {
+        Self {
+            value: Arc::new(AtomicU32::new(0)),
+            lines,
+        }
     }
     fn set(&self, stage: u32) {
-        self.0.store(stage, Ordering::Relaxed);
+        self.value.store(stage, Ordering::Relaxed);
     }
     fn fraction(&self) -> f32 {
-        self.0.load(Ordering::Relaxed) as f32 / (STAGES - 1) as f32
+        self.value.load(Ordering::Relaxed) as f32 / (self.lines.len() - 1) as f32
     }
     fn line(&self) -> &'static str {
-        STAGE_LINES[(self.0.load(Ordering::Relaxed) as usize).min(STAGE_LINES.len() - 1)]
+        self.lines[(self.value.load(Ordering::Relaxed) as usize).min(self.lines.len() - 1)]
     }
 }
 
@@ -13244,6 +14098,12 @@ fn build_renderer(
         &assets.sprite_mips,
         &assets.animations,
         (&atlas.pixels, atlas.width, atlas.height),
+        (&atlas.glint.0, atlas.glint.1, atlas.glint.2),
+        (
+            &atlas.glint_armor.0,
+            atlas.glint_armor.1,
+            atlas.glint_armor.2,
+        ),
         (&pack.forcefield.2, pack.forcefield.0),
         &gui.panorama,
         prepared,
@@ -13270,6 +14130,7 @@ fn loading_renderer(
 ) -> Result<Renderer> {
     static FORCEFIELD: [u8; 4] = [0; 4];
     static EMPTY_HUD: [u8; 4] = [0, 0, 0, 255];
+    static EMPTY_GLINT: [u8; 4] = [0; 4];
     let empty_panorama = horizon_client::gfx::panorama::Faces {
         size: 1,
         pixels: [0u8; 4].repeat(6),
@@ -13280,6 +14141,10 @@ fn loading_renderer(
         Some(atlas) => (atlas.pixels.as_slice(), atlas.width, atlas.height),
         None => (EMPTY_HUD.as_slice(), 1, 1),
     };
+    let (glint_pixels, glint_width, glint_height) = match atlas {
+        Some(atlas) => (atlas.glint.0.as_slice(), atlas.glint.1, atlas.glint.2),
+        None => (EMPTY_GLINT.as_slice(), 1, 1),
+    };
     // A glyph rasterized into an earlier texture is not in these pixels; the
     // new texture gets it again when the character is drawn (see
     // `build_renderer`).
@@ -13296,6 +14161,8 @@ fn loading_renderer(
         &[],
         &[],
         (pixels, width, height),
+        (glint_pixels, glint_width, glint_height),
+        (glint_pixels, glint_width, glint_height),
         (&FORCEFIELD[..], 1),
         panorama,
         None,
@@ -13338,13 +14205,17 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> {
         dark_disc: false,
         outline: Vec::new(),
         outline_after_terrain: false,
+        outline_high_contrast: false,
         debug_lines: &[],
         debug_lines_on_top: &[],
         debug_crosshair: &[],
         hud,
+        glint_alpha: 0.75,
+        glint_ticks: 0.0,
         nether_lighting: false,
         entities: &[],
         entity_spans: &[],
+        glowing: &[],
         dynamic_lights: &[],
         clouds: None,
         lightning: Default::default(),
@@ -13650,6 +14521,11 @@ impl Loading {
         }
     }
     fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        if horizon_threads::stop_requests() > 0 {
+            // No world is open yet: nothing to save.
+            event_loop.exit();
+            return;
+        }
         if let Err(error) = self.poll_menu_resources() {
             self.error = Some(error);
             event_loop.exit();
@@ -13927,6 +14803,9 @@ pub fn run() -> Result<()> {
     {
         horizon_client::heartbeat::start();
     }
+    if options.execution_role.is_client() {
+        horizon_threads::catch_stop_signals();
+    }
     let started = Instant::now();
     horizon_client::spans::enable(options.spikes.is_some());
     let vanilla_root = options.resources.clone();
diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs
index 0f76d0ca9..912bf7c33 100644
--- a/crates/horizon-client/src/game/advancements.rs
+++ b/crates/horizon-client/src/game/advancements.rs
@@ -9,6 +9,7 @@ use horizon_client::{
     text::{self, Style, Text},
     toasts::Slide,
 };
+use horizon_core::geometry::Vec3;
 use serde_json::Value;
 use std::{
     collections::{BTreeMap, BTreeSet, VecDeque},
@@ -82,6 +83,8 @@ pub(super) struct AdvState {
     pub(super) quiet: bool,
     /// The inventory last seen by `inventory_changed`.
     pub(super) last_inventory: u64,
+    /// `ServerPlayer.levitationStartPos` and `levitationStartTime`.
+    pub(super) levitation: Option<([f64; 3], u64)>,
     /// While the game acts for a network player (`as_guest`): the
     /// advancements whose progress changed (`progressChanged`), the recipes
     /// unlocked and the announcements, for their client and everyone's.
@@ -180,6 +183,14 @@ impl adv::World for View<'_, '_> {
             "block" => items.block_tags.get(tag).is_some_and(|t| t.contains(id)),
             "entity_type" => self.0.res.mob_data().entity_has(tag, id),
             "worldgen/biome" => self.0.res.mob_data().biome_has(tag, id),
+            "damage_type" => self
+                .0
+                .res
+                .stations()
+                .enchantments
+                .damage_tags
+                .get(tag)
+                .is_some_and(|t| t.contains(id)),
             _ => false,
         }
     }
@@ -647,6 +658,28 @@ impl Game<'_> {
             };
             adv::conditions(&c["player"], &ctx, w)
         });
+        // ServerPlayer.onEffectAdded and onEffectsRemoved keep the start of a
+        // levitation; tick fires LEVITATION while there is one.
+        let levitating = self
+            .potions
+            .effects
+            .list
+            .iter()
+            .any(|e| e.id == "levitation");
+        match (levitating, self.adv.levitation) {
+            (true, None) => {
+                let at = self
+                    .player
+                    .as_ref()
+                    .map(|p| [p.position.x, p.position.y, p.position.z]);
+                self.adv.levitation = at.map(|at| (at, self.ticks));
+            }
+            (false, Some(_)) => self.adv.levitation = None,
+            _ => {}
+        }
+        if let Some((start, since)) = self.adv.levitation {
+            self.trigger_levitation(start, (self.ticks - since) as i64);
+        }
         if self.ticks.is_multiple_of(20) {
             let me = self.player_entity();
             self.trigger("minecraft:location", |c, w| {
@@ -681,6 +714,123 @@ impl Game<'_> {
             adv::conditions(&c["player"], &pctx, w) && adv::conditions(&c[&key], &ectx, w)
         });
     }
+    /// `LevitationTrigger`: how far the player rose from where it started
+    /// levitating, and for how long.
+    fn trigger_levitation(&mut self, start: [f64; 3], duration: i64) {
+        let me = self.player_entity();
+        self.trigger("minecraft:levitation", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            adv::conditions(&c["player"], &pctx, w)
+                && (c["distance"].is_null() || adv::distance(&c["distance"], start, me.position))
+                && adv::range_i(&c["duration"], duration)
+        });
+    }
+    /// `ServerPlayer.updateUsingItem`: USING_ITEM for the item in use, with
+    /// what the player looks at (`PlayerPredicate.lookingAt`).
+    pub(super) fn trigger_using_item(&mut self, stack: &ItemStack) {
+        if self.remote.is_some() || self.no_player_here() {
+            return;
+        }
+        let mut me = self.player_entity();
+        me.looking_at = self.looking_at_entity().map(Box::new);
+        let it = item_view(stack);
+        self.trigger("minecraft:using_item", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            adv::conditions(&c["player"], &pctx, w) && adv::item(&c["item"], &it, w)
+        });
+    }
+    /// The mob a 100 block ray from the eyes meets first, if no block is in
+    /// the way (`ProjectileUtil.getEntityHitResult` and `hasLineOfSight`).
+    fn looking_at_entity(&self) -> Option<EntityView> {
+        let eye = self.eye_position()?;
+        let dir = super::view_vector(self.yaw, self.pitch);
+        let (m, _) = self
+            .mobs
+            .iter()
+            .filter(|m| m.alive())
+            .filter_map(|m| Some((m, super::ray_box(eye, dir, 100.0, m.bounds())?)))
+            .min_by(|a, b| a.1.total_cmp(&b.1))?;
+        // `LivingEntity.hasLineOfSight`: eye to the target's eye height,
+        // `ClipContext.Block.COLLIDER`, no fluids, within 128 blocks.
+        let from = Vec3::new(eye[0], eye[1], eye[2]);
+        let to = Vec3::new(m.position.x, m.eye_y(), m.position.z);
+        let world = self.mob_world_base(&[]);
+        let clear = to.distance(from) <= 128.0 && world.clear_between(from, to, false);
+        clear.then(|| self.mob_entity(m))
+    }
+    /// `PlayerHurtEntityTrigger`: the player, the damage and the victim.
+    pub(super) fn trigger_player_hurt_entity(
+        &mut self,
+        victim: &EntityView,
+        damage: &adv::DamageView,
+    ) {
+        let me = self.player_entity();
+        let (victim, damage) = (victim.clone(), damage.clone());
+        self.trigger("minecraft:player_hurt_entity", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            let vctx = adv::Entities {
+                this: Some(&victim),
+                ..pctx
+            };
+            adv::conditions(&c["player"], &pctx, w)
+                && adv::damage(&c["damage"], &damage, w, me.position)
+                && adv::conditions(&c["entity"], &vctx, w)
+        });
+    }
+    /// The player's hit on `victim` as `LivingEntity.hurtServer` reports it:
+    /// `kind` damage of `amount` from `direct` (the player's own hand when
+    /// `None`), nothing blocked.
+    pub(super) fn player_hit(
+        &mut self,
+        victim: &EntityView,
+        kind: &str,
+        direct: Option<EntityView>,
+        amount: f32,
+    ) {
+        let me = self.player_entity();
+        self.trigger_player_hurt_entity(
+            victim,
+            &adv::DamageView {
+                kind: kind.to_owned(),
+                is_direct: direct.is_none(),
+                direct: direct.or_else(|| Some(me.clone())),
+                source: Some(me),
+                original: amount,
+                actual: amount,
+                blocked: false,
+            },
+        );
+    }
+    /// `EntityHurtPlayerTrigger`: the player and the damage it took.
+    pub(super) fn trigger_entity_hurt_player(&mut self, damage: &adv::DamageView) {
+        let me = self.player_entity();
+        let damage = damage.clone();
+        self.trigger("minecraft:entity_hurt_player", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            adv::conditions(&c["player"], &pctx, w)
+                && adv::damage(&c["damage"], &damage, w, me.position)
+        });
+    }
     /// A player condition plus one item (`item` key).
     pub(super) fn trigger_item(&mut self, name: &str, stack: &ItemStack) {
         let me = self.player_entity();
@@ -708,6 +858,72 @@ impl Game<'_> {
         let it = item_view(stack);
         self.trigger(name, |c, w| adv::item_entity(c, &me, target, &it, w));
     }
+    /// `BrewedPotionTrigger`: the potion contents of a stack taken from a
+    /// brewing stand.
+    pub(super) fn trigger_brewed_potion(&mut self, stack: &ItemStack) {
+        let me = self.player_entity();
+        let potion = stack.potion().map(str::to_owned);
+        self.trigger("minecraft:brewed_potion", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            adv::conditions(&c["player"], &pctx, w)
+                && adv::potions(&c["potion"], potion.as_deref(), w)
+        });
+    }
+    /// `TradeTrigger`: the villager and the item the trade gave.
+    pub(super) fn trigger_trade(&mut self, villager: &EntityView, stack: &ItemStack) {
+        let me = self.player_entity();
+        let villager = villager.clone();
+        let it = item_view(stack);
+        self.trigger("minecraft:villager_trade", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            let vctx = adv::Entities {
+                this: Some(&villager),
+                ..pctx
+            };
+            adv::conditions(&c["player"], &pctx, w)
+                && adv::conditions(&c["villager"], &vctx, w)
+                && adv::item(&c["item"], &it, w)
+        });
+    }
+    /// `FishingRodHookedTrigger`: the rod, what the hook is in (or the hook)
+    /// and the items it caught.
+    pub(super) fn trigger_fishing_rod_hooked(
+        &mut self,
+        rod: &ItemStack,
+        hooked: &EntityView,
+        items: &[ItemStack],
+    ) {
+        let me = self.player_entity();
+        let rod = item_view(rod);
+        let hooked = hooked.clone();
+        let items: Vec<ItemView> = items.iter().map(item_view).collect();
+        self.trigger("minecraft:fishing_rod_hooked", move |c, w| {
+            let pctx = adv::Entities {
+                this: Some(&me),
+                origin: me.position,
+                tool: None,
+                block_pos: None,
+            };
+            let ectx = adv::Entities {
+                this: Some(&hooked),
+                ..pctx
+            };
+            adv::conditions(&c["player"], &pctx, w)
+                && adv::item(&c["rod"], &rod, w)
+                && adv::conditions(&c["entity"], &ectx, w)
+                && (c["item"].is_null() || items.iter().any(|i| adv::item(&c["item"], i, w)))
+        });
+    }
     /// `EnterBlockTrigger`: the block, its state properties and the player.
     pub(super) fn trigger_enter_block(&mut self, state: horizon_world::registry::BlockStateId) {
         let Some(definition) = self.pack.assets.registry.state(state).cloned() else {
diff --git a/crates/horizon-client/src/game/agent.rs b/crates/horizon-client/src/game/agent.rs
index fa9dbf3c6..4ab0a5189 100644
--- a/crates/horizon-client/src/game/agent.rs
+++ b/crates/horizon-client/src/game/agent.rs
@@ -419,6 +419,9 @@ impl Game<'_> {
             Screen::Advancements => "advancements",
             Screen::WorldOptions => "world-options",
             Screen::Friends => "friends",
+            Screen::ServerLinks => "server-links",
+            Screen::ConfirmLink => "confirm-link",
+            Screen::DialogWarning => "dialog-warning",
             Screen::CommandBlock => "command-block",
             Screen::Win => "win",
             Screen::Mod => "mod",
@@ -565,6 +568,22 @@ impl Game<'_> {
                 "generate_structures": options.structures,
                 "bonus_chest": options.bonus_chest(),
             }),
+            Mode::CreateFlat {
+                name,
+                seed,
+                options,
+                flat,
+                ..
+            } => json!({
+                "mode": "customize-flat",
+                "fields": { "name": name, "seed": seed },
+                "superflat": options.flat,
+                "biome": flat.settings().biome,
+                "layers": flat.settings().layers.iter().map(|layer| json!({
+                    "block": layer.block,
+                    "height": layer.height,
+                })).collect::<Vec<_>>(),
+            }),
             Mode::Edit {
                 world,
                 name,
@@ -707,9 +726,12 @@ impl Game<'_> {
             // the recipe buttons of the page, page arrows, filter and tabs.
             let book = self.recipe_book_targets();
             if !book.is_empty() {
+                let (open, filtering) = self.recipe_book_flags().unwrap_or_default();
                 v["recipe_book"] = json!({
                     "targets": book.iter().map(|t| t.rect).collect::<Vec<_>>(),
                     "known": self.recipe_book_known(),
+                    "open": open,
+                    "filtering": filtering,
                 });
             }
             v["slot_ids"] = json!(
diff --git a/crates/horizon-client/src/game/allays.rs b/crates/horizon-client/src/game/allays.rs
index bed835663..ce9410ba5 100644
--- a/crates/horizon-client/src/game/allays.rs
+++ b/crates/horizon-client/src/game/allays.rs
@@ -131,7 +131,8 @@ impl Game<'_> {
         let m = &mut self.mobs[i];
         m.extra.ints[1] -= 1;
         m.extra.ints[3] = 60;
-        self.spawn_item(ItemStack::new(&item, 1), from, v, 40);
+        // ItemEntity.setDefaultPickUpDelay.
+        self.spawn_item(ItemStack::new(&item, 1), from, v, 10);
         if self.world.game_time % 7 == 0 && self.world.random.next_double() < 0.9 {
             const PITCHES: [f32; 16] = [
                 0.5625, 0.625, 0.75, 0.9375, 1.0, 1.0, 1.125, 1.25, 1.5, 1.875, 2.0, 2.25, 2.5,
@@ -160,7 +161,7 @@ impl Game<'_> {
             }
             // Allay.duplicateAllay: entity event 18, three spawnHeartParticle.
             let id = self.mobs[index].id;
-            self.particles_around_mob(id, "heart", horizon_client::particles::Burst::ALLAY);
+            self.mob_event_particles(id, 18);
             self.audio
                 .play("minecraft:block.amethyst_block.chime", Some(at), 2.0, 1.0);
             self.consume_held();
diff --git a/crates/horizon-client/src/game/armor_stands.rs b/crates/horizon-client/src/game/armor_stands.rs
index f175af401..8cd8be53a 100644
--- a/crates/horizon-client/src/game/armor_stands.rs
+++ b/crates/horizon-client/src/game/armor_stands.rs
@@ -453,6 +453,11 @@ impl Game<'_> {
         }
         // ArmorStand.swapItem.
         match held {
+            // A player with infinite materials puts a copy of one on an empty
+            // slot and keeps the stack.
+            Some(h) if self.creative && current.is_none() => {
+                self.armor_stands[i].equipment[slot] = Some(ItemStack { count: 1, ..h });
+            }
             Some(h) if h.count > 1 => {
                 if current.is_some() {
                     return true;
@@ -706,6 +711,20 @@ impl Game<'_> {
                 let color = undyed.map_or(0xFFFF_FFFF, |c| {
                     0xFF00_0000 | (c & 0xFF) << 16 | (c & 0xFF00) | (c >> 16) & 0xFF
                 });
+                // ArmorStandRenderer's HumanoidArmorLayer: the armour glint
+                // when `stack.hasFoil()`, as on a living entity.
+                let item_glint = self
+                    .res
+                    .items()
+                    .enchantments
+                    .props
+                    .get(&stack.item)
+                    .is_some_and(|p| p.glint);
+                let overlay = if stack.has_foil(item_glint) {
+                    horizon_client::mobs::render::ARMOR_GLINT
+                } else {
+                    0
+                };
                 let layer_poses = Poses::new(part);
                 horizon_client::mobs::render::draw(
                     part,
@@ -714,7 +733,7 @@ impl Game<'_> {
                     uv,
                     color,
                     packed,
-                    0,
+                    overlay,
                     out,
                 );
                 // EquipmentLayerRenderer: the trim layer over the armour.
@@ -729,7 +748,7 @@ impl Game<'_> {
                         trim,
                         0xFFFF_FFFF,
                         packed,
-                        0,
+                        overlay,
                         out,
                     );
                 }
@@ -872,6 +891,7 @@ impl Game<'_> {
                 lights: Some(horizon_client::block_entity_render::diffuse_lights(
                     self.dim == super::Dim::Nether,
                 )),
+                glint: self.glint(),
             };
             let profile = stack
                 .extra
diff --git a/crates/horizon-client/src/game/beehives.rs b/crates/horizon-client/src/game/beehives.rs
index b7f7efb1a..e17a8f6a3 100644
--- a/crates/horizon-client/src/game/beehives.rs
+++ b/crates/horizon-client/src/game/beehives.rs
@@ -3,8 +3,10 @@
 //! player breaks the hive or fire reaches it.
 use super::Game;
 use horizon_client::{
+    Result,
     beehive::{self, Beehive, HiveHost, Release},
     containers::BlockEntity,
+    items::ItemStack,
     mobs::{Mob, Who, bee},
 };
 use horizon_core::{
@@ -194,19 +196,139 @@ impl Game<'_> {
         }
         self.anger_nearby_bees(at);
     }
+    /// `BeehiveBlock.useItemOn` with `held` in the acting hand: shears take
+    /// the honeycombs and a glass bottle a honey bottle from a full hive
+    /// (honey level 5), then the honey level resets and, unless a campfire
+    /// smokes the hive, the bees come out angry. True when it took the click.
+    pub(super) fn use_beehive(&mut self, pos: [i32; 3], held: Option<&ItemStack>) -> Result<bool> {
+        let Some(held) = held else { return Ok(false) };
+        let shears = &*held.item == "minecraft:shears";
+        if !shears && &*held.item != "minecraft:glass_bottle" {
+            return Ok(false);
+        }
+        let state = self.world.block(pos[0], pos[1], pos[2]);
+        if !matches!(
+            &*self.res.facts().get(state).name,
+            "minecraft:beehive" | "minecraft:bee_nest"
+        ) {
+            return Ok(false);
+        }
+        let prop = |key: &str| {
+            self.pack
+                .assets
+                .registry
+                .state(state)
+                .and_then(|s| s.properties.get(key).cloned())
+        };
+        if prop("honey_level").and_then(|v| v.parse::<i32>().ok()) != Some(5) {
+            return Ok(false);
+        }
+        let facing = beehive::facing_step(prop("facing").as_deref());
+        let at = self
+            .player
+            .as_ref()
+            .map(|p| [p.position.x, p.position.y, p.position.z]);
+        if shears {
+            // dropHoneycomb (harvest/beehive), the shear sound, hurtAndBreak.
+            for stack in self.sequence_loot(
+                "minecraft:harvest/beehive",
+                "minecraft:harvest/beehive",
+                Some(held),
+            ) {
+                self.pop_resource(pos, stack);
+            }
+            self.audio
+                .play("minecraft:block.beehive.shear", at, 1.0, 1.0);
+            self.damage_held(1);
+            self.post_block_game_event("minecraft:shear", pos, self.sculk_actor(), None);
+        } else {
+            // shrink(1), then the honey bottle in the hand, the inventory or
+            // on the ground.
+            self.audio.play("minecraft:item.bottle.fill", at, 1.0, 1.0);
+            let cell = self.held_mut();
+            if let Some(s) = cell.as_mut() {
+                s.count -= 1;
+                if s.count == 0 {
+                    *cell = None;
+                }
+            }
+            let bottle = ItemStack::new("minecraft:honey_bottle", 1);
+            if self.held().is_none() {
+                *self.held_mut() = Some(bottle);
+            } else if let Some(rest) = self.give(bottle)
+                && let Some(eye) = self.eye_position()
+            {
+                self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40);
+            }
+            self.post_block_game_event("minecraft:fluid_pickup", pos, self.sculk_actor(), None);
+        }
+        self.stats.add("used", &held.item, 1);
+        let smokey = beehive::smokey(&self.mob_world_base(&[]), pos);
+        let key = (pos[0], pos[1], pos[2]);
+        if !smokey
+            && matches!(self.world.block_entities.get(&key), Some(BlockEntity::Beehive(h)) if !h.bees.is_empty())
+        {
+            self.anger_nearby_bees(pos);
+        }
+        // resetHoneyLevel.
+        if let Some(reset) = self.with_props(state, &[("honey_level", "0")]) {
+            self.level_set(pos, reset)?;
+        }
+        if !smokey
+            && let Some(BlockEntity::Beehive(mut hive)) = self.world.block_entities.take(&key)
+        {
+            // emptyAllLivingFromHive: the bees within 4 blocks of the player
+            // go for them.
+            let released = hive.release_all(
+                pos,
+                facing,
+                None,
+                Release::Emergency,
+                &mut GameHive { game: self },
+            );
+            self.world
+                .block_entities
+                .put(key, BlockEntity::Beehive(hive));
+            if let Some(p) = self.player_view().map(|p| p.position) {
+                for m in self.mobs.iter_mut().filter(|m| released.contains(&m.id)) {
+                    if m.distance_sqr(p) <= 16.0 {
+                        m.ai.target = Some(Who::Player);
+                    }
+                }
+            }
+        }
+        // ServerPlayerGameMode.useItemOn: the action was consumed.
+        self.trigger_block("minecraft:item_used_on_block", pos, held);
+        Ok(true)
+    }
     /// `BeehiveBlock.angerNearbyBees`: bees within 8 blocks (6 up and down)
-    /// without a target go for a player in the same box.
-    fn anger_nearby_bees(&mut self, at: [i32; 3]) {
+    /// without a target go for a random player in the same box, the window's
+    /// own or a guest (`None` is the window's player).
+    pub(super) fn anger_nearby_bees(&mut self, at: [i32; 3]) {
         let min = Vec3::new(
             f64::from(at[0]) - 8.0,
             f64::from(at[1]) - 6.0,
             f64::from(at[2]) - 8.0,
         );
         let area = Aabb::new(min, Vec3::new(min.x + 17.0, min.y + 13.0, min.z + 17.0));
-        if !self
+        let mut players: Vec<Option<u32>> = Vec::new();
+        if self
             .player_view()
             .is_some_and(|p| p.bounds.intersects(area))
         {
+            players.push(None);
+        }
+        if let Some(host) = self.lan.as_ref() {
+            players.extend(
+                host.hub
+                    .guests
+                    .iter()
+                    .filter(|g| host.hub.here(g) && g.loaded && !g.dead)
+                    .filter(|g| super::lan_mobs::guest_bounds(g).intersects(area))
+                    .map(|g| Some(g.conn)),
+            );
+        }
+        if players.is_empty() {
             return;
         }
         let mut bees: Vec<usize> = (0..self.mobs.len())
@@ -219,9 +341,20 @@ impl Game<'_> {
             .collect();
         bees.retain(|&i| self.mobs[i].ai.target.is_none());
         for i in bees {
-            // Util.getRandom over the one player.
-            let _ = self.world.random.next_int_bound(1);
+            // Util.getRandom over the players.
+            let pick = self
+                .world
+                .random
+                .next_int_bound(players.len() as i32)
+                .unwrap_or(0) as usize;
             self.mobs[i].ai.target = Some(Who::Player);
+            // The player a mob sees is its guest binding, else the window's.
+            if let Some(host) = self.lan.as_mut() {
+                match players[pick] {
+                    Some(conn) => host.mob_players.insert(self.mobs[i].id, conn),
+                    None => host.mob_players.remove(&self.mobs[i].id),
+                };
+            }
         }
     }
 }
diff --git a/crates/horizon-client/src/game/block_entity_anims.rs b/crates/horizon-client/src/game/block_entity_anims.rs
index 3d452596e..2705d8388 100644
--- a/crates/horizon-client/src/game/block_entity_anims.rs
+++ b/crates/horizon-client/src/game/block_entity_anims.rs
@@ -5,10 +5,14 @@
 //! [`Game::block_anim`] and [`Game::chest_lid`].
 use super::Game;
 use horizon_client::{
-    block_entity_anim::{BellEntity, EndGateway, Shulker, ShulkerStatus, Ticker},
+    block_entity_anim::{
+        BellEntity, ConduitServer, ConduitTarget, EndGateway, Shulker, ShulkerStatus, Ticker,
+    },
     block_entity_render::BlockAnim,
     collisions::{SceneCollisions, no_collision_empty},
     containers::BlockEntity,
+    effects::EffectInstance,
+    mobs::{Damage, DamageKind},
     particles::{ParticleOptions, ParticleType},
     save::number,
     skins,
@@ -16,6 +20,7 @@ use horizon_client::{
 use horizon_core::{
     geometry::{Aabb, Vec3},
     position::BlockPos,
+    random::RandomSource,
 };
 use horizon_world::nbt::Tag;
 
@@ -71,23 +76,24 @@ impl Game<'_> {
     /// A player opened (`open`) or closed the container at `key`: the opener
     /// count block event (`ContainerOpenersCounter` / `ShulkerBoxBlockEntity`
     /// `startOpen`/`stopOpen`) for chests, ender chests and shulker boxes,
-    /// on both halves of a double chest (`CompoundContainer`).
-    pub(super) fn container_opener_event(&mut self, key: (i32, i32, i32), open: bool) {
+    /// on both halves of a double chest (`CompoundContainer`). True when the
+    /// count went from 0 to 1 or back to 0: the only moments the container
+    /// plays its open or close sound.
+    pub(super) fn container_opener_event(&mut self, key: (i32, i32, i32), open: bool) -> bool {
         // Spectators never count as openers.
-        if !self.spectator() {
-            self.container_openers_changed(key, open);
-        }
+        !self.spectator() && self.container_openers_changed(key, open)
     }
     /// `container_opener_event` for a player who is not a spectator (a guest).
-    pub(super) fn container_openers_changed(&mut self, key: (i32, i32, i32), open: bool) {
+    pub(super) fn container_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool {
         let pos = [key.0, key.1, key.2];
         let state = self.world.block(pos[0], pos[1], pos[2]).0;
         match self.be_anims.ticker(state) {
             Some(Ticker::Lid) => {
-                self.lid_openers_changed(key, open);
+                let edge = self.lid_openers_changed(key, open);
                 if let Some(other) = self.chest_other_half(key) {
                     self.lid_openers_changed(other, open);
                 }
+                edge
             }
             _ if self
                 .res
@@ -97,26 +103,27 @@ impl Game<'_> {
                 .as_ref()
                 == "minecraft:barrel" =>
             {
-                self.barrel_openers_changed(key, open);
+                self.barrel_openers_changed(key, open)
             }
             Some(Ticker::Shulker { .. }) => {
                 let shulker = self.be_anims.shulkers.entry(pos).or_default();
-                let (count, _) = if open {
+                let (count, edge) = if open {
                     shulker.start_open()
                 } else {
                     shulker.stop_open()
                 };
                 self.block_entity_event(pos, 1, count);
                 self.lan_block_event(pos, 1, count);
+                edge
             }
-            _ => {}
+            _ => false,
         }
     }
     /// `ContainerOpenersCounter.incrementOpeners` / `decrementOpeners` of the
     /// chest at `key` (the host and the guests are counted), then
     /// `ChestBlockEntity.signalOpenCount`: block event 1 with the count, here
-    /// and for the guests.
-    fn lid_openers_changed(&mut self, key: (i32, i32, i32), open: bool) {
+    /// and for the guests. True when the count crossed zero.
+    fn lid_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool {
         let (before, count) = self.count_opener(key, open);
         let pos = [key.0, key.1, key.2];
         self.block_entity_event(pos, 1, count);
@@ -134,12 +141,15 @@ impl Game<'_> {
                 b.update_neighbors_at(level, ticks, p.offset(0, -1, 0), block);
             });
         }
+        (before == 0) != (count == 0)
     }
     /// `BarrelBlockEntity.openersCounter`: the first opener opens the barrel
     /// (`open=true`), the last one to leave closes it (`updateBlockState`).
-    fn barrel_openers_changed(&mut self, key: (i32, i32, i32), open: bool) {
+    /// True when the count crossed zero.
+    fn barrel_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool {
         let (before, count) = self.count_opener(key, open);
-        if (before == 0) != (count == 0) {
+        let edge = (before == 0) != (count == 0);
+        if edge {
             self.set_bool_prop(
                 key,
                 "open",
@@ -147,6 +157,7 @@ impl Game<'_> {
                 horizon_world::level::flags::UPDATE_ALL,
             );
         }
+        edge
     }
     /// One opener more (`open`) or less at `key`: the count before and after
     /// (`ContainerOpenersCounter.incrementOpeners` / `decrementOpeners`).
@@ -218,9 +229,12 @@ impl Game<'_> {
     /// The client tickers of the loaded animated block entities, once per
     /// client tick (`ClientLevel.tickBlockEntities`).
     pub(super) fn tick_block_entity_anims(&mut self) {
+        // A server has no window, but its gateways and conduits still run
+        // their server tickers; a client of one only animates what it is sent.
+        if self.remote.is_none() {
+            self.tick_conduit_servers();
+        }
         let Some(r) = &self.renderer else {
-            // A server has no window, but its gateways still run their
-            // server ticker.
             if self.remote.is_none() {
                 self.tick_gateway_servers();
             }
@@ -337,6 +351,7 @@ impl Game<'_> {
                     }
                 }
                 Ticker::Conduit => {
+                    let target = self.conduit_target(pos);
                     let world = &self.world;
                     let facts = self.res.facts();
                     let registry = self.pack.assets.registry;
@@ -356,7 +371,7 @@ impl Game<'_> {
                         time,
                         is_water,
                         is_frame,
-                        None,
+                        target,
                         self.particles.random(),
                     );
                     let nautilus = ParticleOptions::simple(ParticleType::Nautilus);
@@ -383,6 +398,248 @@ impl Game<'_> {
         }
         self.be_anims.present = positions;
     }
+    /// `ConduitBlockEntity.serverTick` of every conduit in the chunks that
+    /// tick blocks, with or without a renderer. The conduits are looked for
+    /// when the shape is checked, every 40 ticks (they have no block entity
+    /// of their own here).
+    fn tick_conduit_servers(&mut self) {
+        if self.world.game_time % 40 == 0 {
+            self.find_conduits();
+        }
+        let mut positions: Vec<[i32; 3]> = self.be_anims.conduit_servers.keys().copied().collect();
+        positions.sort_unstable();
+        for pos in positions {
+            self.tick_conduit_server(pos);
+        }
+    }
+    /// Sets `be_anims.conduit_servers` to the conduits in the
+    /// chunks that tick blocks, keeping the state of those already known.
+    fn find_conduits(&mut self) {
+        let levels = self.tickets.levels();
+        let kinds = &self.be_anims.kinds;
+        let is_conduit = |id: u32| matches!(kinds.get(id as usize), Some(Some(Ticker::Conduit)));
+        let mut found = Vec::new();
+        for (&(cx, cz), chunk) in &self.world.chunks {
+            if !levels.block_ticking_at(cx * 16, cz * 16) {
+                continue;
+            }
+            for (si, section) in chunk.sections.iter().enumerate() {
+                if !section.blocks.maybe_has(is_conduit) {
+                    continue;
+                }
+                for i in 0..4096 {
+                    if is_conduit(section.get(i)) {
+                        found.push([
+                            cx * 16 + (i & 15) as i32,
+                            horizon_client::chunk::MIN_Y + si as i32 * 16 + (i >> 8) as i32,
+                            cz * 16 + ((i >> 4) & 15) as i32,
+                        ]);
+                    }
+                }
+            }
+        }
+        let mut old = std::mem::take(&mut self.be_anims.conduit_servers);
+        for pos in found {
+            let known = old.remove(&pos).unwrap_or_default();
+            self.be_anims.conduit_servers.insert(pos, known);
+        }
+    }
+    /// `ConduitBlockEntity.serverTick` of the conduit at `pos`, in a chunk
+    /// that ticks blocks: the shape check every 40 ticks with its sounds, the
+    /// power for players in range, the hurt for an enemy, then the ambient
+    /// sounds.
+    fn tick_conduit_server(&mut self, pos: [i32; 3]) {
+        let state = self.world.block(pos[0], pos[1], pos[2]).0;
+        if self.be_anims.ticker(state) != Some(Ticker::Conduit) {
+            // Broken since the chunks were searched.
+            self.be_anims.conduit_servers.remove(&pos);
+            return;
+        }
+        if !self.tickets.levels().block_ticking_at(pos[0], pos[2])
+            || !self.border.contains(f64::from(pos[0]), f64::from(pos[2]))
+        {
+            return;
+        }
+        let time = self.world.game_time;
+        let mut conduit = self
+            .be_anims
+            .conduit_servers
+            .remove(&pos)
+            .unwrap_or_default();
+        let check = {
+            let world = &self.world;
+            let facts = self.res.facts();
+            let registry = self.pack.assets.registry;
+            let frames = self
+                .res
+                .items()
+                .block_tags
+                .get("minecraft:conduit_effect_block");
+            // Level.isWaterAt: the fluid at the position is water.
+            let is_water = |p: [i32; 3]| {
+                facts.get(world.block(p[0], p[1], p[2])).fluid
+                    == horizon_client::blocks::Fluid::Water
+            };
+            let is_frame = |p: [i32; 3]| {
+                registry
+                    .state(world.block(p[0], p[1], p[2]))
+                    .is_some_and(|s| frames.is_some_and(|f| f.contains(&s.name)))
+            };
+            conduit.check(pos, time, is_water, is_frame)
+        };
+        let centre = [
+            f64::from(pos[0]) + 0.5,
+            f64::from(pos[1]) + 0.5,
+            f64::from(pos[2]) + 0.5,
+        ];
+        if let Some(check) = check {
+            if let Some(active) = check.toggled {
+                let sound = if active {
+                    "minecraft:block.conduit.activate"
+                } else {
+                    "minecraft:block.conduit.deactivate"
+                };
+                self.audio.play(sound, Some(centre), 1.0, 1.0);
+            }
+            if let Some(frames) = check.frames {
+                self.conduit_apply_effects(pos, frames);
+                self.conduit_attack(&mut conduit, pos, frames >= 42);
+            }
+        }
+        let (ambient, short) = conduit.ambient(time, &mut self.world.random);
+        if ambient {
+            self.audio
+                .play("minecraft:block.conduit.ambient", Some(centre), 1.0, 1.0);
+        }
+        if short {
+            self.audio.play(
+                "minecraft:block.conduit.ambient_short",
+                Some(centre),
+                1.0,
+                1.0,
+            );
+        }
+        self.be_anims.conduit_servers.insert(pos, conduit);
+    }
+    /// `ConduitBlockEntity.applyEffects`: conduit power for every player
+    /// in water or rain within `frames / 7 * 16` blocks.
+    fn conduit_apply_effects(&mut self, pos: [i32; 3], frames: usize) {
+        let range = (frames / 7 * 16) as i64;
+        self.for_each_player(|g| {
+            let Some(p) = g.player.as_ref().filter(|p| !p.health.dead_or_dying()) else {
+                return;
+            };
+            if g.spectator() {
+                return;
+            }
+            let at = p.position;
+            let in_water = p.fluids.was_touching_water;
+            let top = at.y + f64::from(p.dimensions.height);
+            // BlockPos.closerThan: the squared distance under range squared.
+            let d = [at.x, at.y, at.z]
+                .map(|v| v.floor() as i64)
+                .iter()
+                .zip(pos)
+                .map(|(a, b)| (a - i64::from(b)).pow(2))
+                .sum::<i64>();
+            if d >= range * range || !(in_water || g.in_rain(at, top)) {
+                return;
+            }
+            let power = EffectInstance {
+                ambient: true,
+                ..EffectInstance::new("conduit_power", 260, 0)
+            };
+            g.potions.effects.add(power);
+        });
+    }
+    /// `Entity.isInRain`: rain at the block position or at the top of the box.
+    pub(super) fn in_rain(&mut self, at: Vec3, top: f64) -> bool {
+        let p = BlockPos::new(
+            at.x.floor() as i32,
+            at.y.floor() as i32,
+            at.z.floor() as i32,
+        );
+        let up = BlockPos::new(p.x, top.floor() as i32, p.z);
+        self.with_level(|b, level, _| b.is_raining_at(level, p) || b.is_raining_at(level, up))
+    }
+    /// `ConduitBlockEntity.updateAndAttackTarget`: while the conduit hunts
+    /// (42 frame blocks) its target stays until it dies or leaves the 8
+    /// blocks, else a random enemy in water or rain is chosen; the target
+    /// takes 4 magic damage.
+    fn conduit_attack(&mut self, conduit: &mut ConduitServer, pos: [i32; 3], hunting: bool) {
+        conduit.target = match conduit.target {
+            _ if !hunting => None,
+            None => self.conduit_new_target(pos),
+            Some(id) => self
+                .mobs
+                .iter()
+                .find(|m| m.id == id && !m.removed)
+                .filter(|m| {
+                    let at = [m.position.x, m.position.y, m.position.z].map(|v| v.floor() as i64);
+                    m.alive()
+                        && at
+                            .iter()
+                            .zip(pos)
+                            .map(|(a, b)| (a - i64::from(b)).pow(2))
+                            .sum::<i64>()
+                            < 64
+                })
+                .map(|m| m.id),
+        };
+        let Some(m) = conduit
+            .target
+            .and_then(|id| self.mobs.iter_mut().find(|m| m.id == id))
+        else {
+            return;
+        };
+        let at = [m.position.x, m.position.y, m.position.z];
+        m.damage(4.0, Damage::of(DamageKind::Magic));
+        self.audio
+            .play("minecraft:block.conduit.attack.target", Some(at), 1.0, 1.0);
+    }
+    /// `ConduitBlockEntity.selectNewTarget`: one of the enemies in water or
+    /// rain whose box meets the conduit's block inflated by 8.
+    fn conduit_new_target(&mut self, pos: [i32; 3]) -> Option<u32> {
+        let [x, y, z] = pos.map(f64::from);
+        let area = Aabb::new(
+            Vec3::new(x - 8.0, y - 8.0, z - 8.0),
+            Vec3::new(x + 9.0, y + 9.0, z + 9.0),
+        );
+        let near: Vec<(u32, bool, Vec3, f64)> = self
+            .mobs
+            .iter()
+            .filter(|m| m.hostile() && !m.removed && m.bounds().intersects(area))
+            .map(|m| {
+                let top = m.position.y + f64::from(m.height());
+                (m.id, m.fluids.in_water, m.position, top)
+            })
+            .collect();
+        let candidates: Vec<u32> = near
+            .into_iter()
+            .filter(|&(_, in_water, at, top)| in_water || self.in_rain(at, top))
+            .map(|(id, ..)| id)
+            .collect();
+        if candidates.is_empty() {
+            return None;
+        }
+        let pick = self
+            .world
+            .random
+            .next_int_bound(candidates.len() as i32)
+            .unwrap_or(0);
+        Some(candidates[pick as usize])
+    }
+    /// The conduit's `destroyTarget` as the client draws it.
+    fn conduit_target(&self, pos: [i32; 3]) -> Option<ConduitTarget> {
+        let id = self.be_anims.conduit_servers.get(&pos)?.target?;
+        let m = self.mobs.iter().find(|m| m.id == id && !m.removed)?;
+        Some(ConduitTarget {
+            position: [m.position.x, m.position.y, m.position.z],
+            eye_y: m.eye_y(),
+            width: m.width(),
+            height: m.height(),
+        })
+    }
     /// `TheEndGatewayBlockEntity.portalTick` (the server ticker) of the
     /// gateways a server keeps a copy of, in block-ticking chunks
     /// (`Level.tickBlockEntities`): the cooldown an entry started runs out,
@@ -474,21 +731,38 @@ impl Game<'_> {
     /// the player head at `pos`. The skin download is started here; while it
     /// is in flight (or when it cannot be got) the profile's default skin
     /// stands in. A head with no profile answers None: `SKIN_BY_TYPE`.
-    pub(super) fn skull_skin_at(&self, pos: [i32; 3]) -> Option<&str> {
+    pub(super) fn skull_skin_at(&self, pos: [i32; 3]) -> Option<String> {
         let Some(BlockEntity::Skull(skull)) =
             self.world.block_entities.get(&(pos[0], pos[1], pos[2]))
         else {
             return None;
         };
         let skin = skull.skin.as_ref()?;
-        if let Some((url, location)) = &skin.download {
-            self.skin_downloads
-                .borrow_mut()
-                .state(skins::Kind::Skin, url);
-            if self.gui.atlas.sprites.contains_key(location) {
+        // The texture a packed or resolved `textures` property fetches: the
+        // download of a static profile, or the one the services answer for a
+        // `Dynamic` (name- or id-only) profile.
+        let download = skin.download.clone().or_else(|| {
+            let key = skin.dynamic.as_ref()?;
+            let skins::Resolve::Done(Some(profile)) = self.skin_profiles.borrow_mut().state(key)
+            else {
+                return None;
+            };
+            let (value, signature) = profile.textures()?;
+            let url = skins::unpack(&value, signature, &skins::TEXTURE_URIS).skin?;
+            let location = skins::skin_location(&skins::texture_hash(&url)?);
+            Some((url, location))
+        });
+        if let Some((url, location)) = download {
+            let mut downloads = self.skin_downloads.borrow_mut();
+            if self.gui.atlas.sprites.contains_key(&location) {
+                let _ = downloads.state(skins::Kind::Skin, &url);
                 return Some(location);
             }
+            // Its slot was evicted: offer the image again.
+            if downloads.state(skins::Kind::Skin, &url) == skins::Download::Ready {
+                downloads.again(&location);
+            }
         }
-        Some(skin.fallback)
+        Some(skin.fallback.to_owned())
     }
 }
diff --git a/crates/horizon-client/src/game/block_entity_ticks.rs b/crates/horizon-client/src/game/block_entity_ticks.rs
index e0798b4cb..2778bb531 100644
--- a/crates/horizon-client/src/game/block_entity_ticks.rs
+++ b/crates/horizon-client/src/game/block_entity_ticks.rs
@@ -10,6 +10,7 @@ use horizon_client::{
     block_entities::{Pos, Ticking},
     containers::{BlockEntity, FurnaceKind, HOPPER_SLOTS},
 };
+use horizon_core::position::BlockPos;
 use horizon_world::registry::BlockStateId;
 
 impl Game<'_> {
@@ -56,6 +57,7 @@ impl Game<'_> {
                 Some(BlockEntity::Beehive(_)) => self.tick_beehive(pos),
                 Some(BlockEntity::Furnace(_)) => self.tick_furnace(pos)?,
                 Some(BlockEntity::Brewing(_)) => self.tick_brewing_stand(pos)?,
+                Some(BlockEntity::DaylightDetector) => self.tick_daylight_detector(pos),
                 Some(BlockEntity::Campfire(_)) => self.tick_campfire(pos)?,
                 _ => {}
             }
@@ -94,6 +96,7 @@ impl Game<'_> {
                     | "minecraft:beehive"
                     | "minecraft:bee_nest"
                     | "minecraft:brewing_stand"
+                    | "minecraft:daylight_detector"
                     // Lit, cookTick; unlit, cooldownTick.
                     | "minecraft:campfire"
                     | "minecraft:soul_campfire" => Ticking::Yes,
@@ -117,6 +120,16 @@ impl Game<'_> {
         let levels = self.tickets.levels();
         move |x, z| levels.block_ticking_at(x, z)
     }
+    /// `DaylightDetectorBlock.tickEntity` of the detector at `pos`.
+    fn tick_daylight_detector(&mut self, pos: Pos) {
+        // It updates every 20 game ticks (the behaviour checks this too).
+        if self.world.game_time % 20 != 0 {
+            return;
+        }
+        let at = BlockPos::new(pos.0, pos.1, pos.2);
+        self.with_level(|b, level, ticks| b.tick_daylight_detector(level, ticks, at));
+        let _ = self.process_level_events();
+    }
     /// `AbstractFurnaceBlockEntity.serverTick` of the furnace at `pos`, and
     /// its block's `lit` following it.
     fn tick_furnace(&mut self, pos: Pos) -> Result<()> {
diff --git a/crates/horizon-client/src/game/boats.rs b/crates/horizon-client/src/game/boats.rs
index 06dfab22d..7e80f6f58 100644
--- a/crates/horizon-client/src/game/boats.rs
+++ b/crates/horizon-client/src/game/boats.rs
@@ -862,7 +862,7 @@ impl Game<'_> {
         let a = alpha as f32;
         let range = super::entity_culling::default_range(
             glam::DVec3::new(WIDTH, HEIGHT, WIDTH),
-            self.settings.entity_distance,
+            self.view_scale(),
         );
         for b in &self.boats {
             let entity_start = out.len();
diff --git a/crates/horizon-client/src/game/books.rs b/crates/horizon-client/src/game/books.rs
index 2f38dffd9..ddbe47481 100644
--- a/crates/horizon-client/src/game/books.rs
+++ b/crates/horizon-client/src/game/books.rs
@@ -8,7 +8,7 @@ use horizon_client::{
     containers::{BlockEntity, Lectern},
     first_person::Hand,
     hud::{HudBatch, rgba},
-    item_data::WrittenBook,
+    item_data::{StackData, WrittenBook},
     items::ItemStack,
     menu::{Kind, Menu},
     text::Text,
@@ -59,14 +59,86 @@ pub(super) enum BookScreen {
         page_edit: ui::EditBox,
     },
     View {
-        pages: Vec<String>,
+        pages: Vec<Text>,
         page: usize,
         lectern: Option<(i32, i32, i32)>,
     },
 }
+/// The pages a book screen reads: a written book's components (so their
+/// click events stay), else a writable book's text.
+fn view_pages(data: Option<&StackData>) -> Vec<Text> {
+    let Some(data) = data else { return Vec::new() };
+    let Some(w) = &data.written else {
+        return data.writable_pages.iter().map(Text::literal).collect();
+    };
+    let tagged = w.page_tags.len() == w.pages.len();
+    w.pages
+        .iter()
+        .enumerate()
+        .map(|(i, page)| match tagged.then(|| &w.page_tags[i]) {
+            Some(tag @ horizon_world::nbt::Tag::Compound(_)) => {
+                horizon_client::entity_nbt::name_text(tag)
+            }
+            _ => Text::literal(page),
+        })
+        .collect()
+}
 impl Game<'_> {
     fn book_lines(&self, page: &str) -> Vec<Text> {
-        self.gui.atlas.font.split(&Text::literal(page), 114.0)
+        self.page_lines(&Text::literal(page))
+    }
+    fn page_lines(&self, page: &Text) -> Vec<Text> {
+        self.gui.atlas.font.split(page, 114.0)
+    }
+    /// `BookViewScreen.mouseClicked`: the click event of the text under the
+    /// cursor on the page.
+    fn book_link_at(&self, page: &Text, left: f32) -> Option<horizon_client::text::ClickEvent> {
+        let (mx, my) = self.cursor;
+        let row = ((my - 32.0) / 9.0).floor();
+        if row < 0.0 || row >= LINES as f32 {
+            return None;
+        }
+        let lines = self.page_lines(page);
+        let line = lines.get(row as usize)?.resolve_legacy();
+        let mut x = mx - (left + 36.0);
+        if x < 0.0 {
+            return None;
+        }
+        for (c, style) in line.chars() {
+            x -= self.gui.atlas.font.advance(c, style);
+            if x < 0.0 {
+                return style.click.clone();
+            }
+        }
+        None
+    }
+    /// `BookViewScreen.handleClickEvent`: a page link turns to its page
+    /// (`forcePage`), a web link goes through the confirm-link flow.
+    fn book_follow_link(
+        &mut self,
+        link: horizon_client::text::ClickEvent,
+        count: usize,
+        lectern: Option<(i32, i32, i32)>,
+    ) {
+        use horizon_client::text::ClickEvent;
+        match link {
+            ClickEvent::ChangePage(target) => {
+                let target = (target - 1).clamp(0, count.saturating_sub(1) as i32);
+                let Some(BookScreen::View { page, .. }) = self.book.as_mut() else {
+                    return;
+                };
+                if let Some(key) = lectern {
+                    // LecternScreen.forcePage: the menu's button 100 + page.
+                    if target != *page as i32 {
+                        self.lectern_button(key, 100 + target);
+                    }
+                } else if target != *page as i32 {
+                    *page = target as usize;
+                }
+            }
+            ClickEvent::OpenUrl(url) => self.click_url(url),
+            _ => {}
+        }
     }
     /// `WritableBookItem.use` / `WrittenBookItem.use` (`Player.openItemGui`).
     /// A server's player writes in its own client's editor
@@ -115,11 +187,7 @@ impl Game<'_> {
                 }
             }
             "minecraft:written_book" => BookScreen::View {
-                pages: stack
-                    .data()
-                    .and_then(|d| d.written.as_ref())
-                    .map(|w| w.pages.clone())
-                    .unwrap_or_default(),
+                pages: view_pages(stack.data()),
                 page: 0,
                 lectern: None,
             },
@@ -215,6 +283,7 @@ impl Game<'_> {
                 author,
                 generation: 0,
                 pages,
+                page_tags: Vec::new(),
             });
             *stack = written;
         } else {
@@ -685,11 +754,7 @@ impl Game<'_> {
             return false;
         };
         let Some(book) = &l.book else { return false };
-        let data = book.data();
-        let pages = data
-            .and_then(|d| d.written.as_ref().map(|w| w.pages.clone()))
-            .or_else(|| data.map(|d| d.writable_pages.clone()))
-            .unwrap_or_default();
+        let pages = view_pages(book.data());
         let page = (l.page.max(0) as usize).min(pages.len().saturating_sub(1));
         self.stats.custom("interact_with_lectern", 1);
         self.open_book(BookScreen::View {
@@ -811,11 +876,7 @@ impl Game<'_> {
             page,
         }) = self.book.as_mut()
         {
-            let data = book.as_ref().and_then(ItemStack::data);
-            *pages = data
-                .and_then(|d| d.written.as_ref().map(|w| w.pages.clone()))
-                .or_else(|| data.map(|d| d.writable_pages.clone()))
-                .unwrap_or_default();
+            *pages = view_pages(book.as_ref().and_then(ItemStack::data));
             *page = (*page).min(pages.len().saturating_sub(1));
         }
     }
@@ -955,7 +1016,10 @@ impl Game<'_> {
                 lectern,
             }) => {
                 let (page, count, lectern) = (*page, pages.len(), *lectern);
-                if page + 1 < count && inside(left + 116.0, 159.0, 23.0, 13.0) {
+                // The text's click event first, then the buttons.
+                if let Some(link) = pages.get(page).and_then(|t| self.book_link_at(t, left)) {
+                    self.book_follow_link(link, count, lectern);
+                } else if page + 1 < count && inside(left + 116.0, 159.0, 23.0, 13.0) {
                     self.turn_page(true);
                 } else if page > 0 && inside(left + 43.0, 159.0, 23.0, 13.0) {
                     self.turn_page(false);
@@ -1009,9 +1073,12 @@ impl Game<'_> {
             }
         };
         let indicator = |batch: &mut HudBatch, page: usize, count: usize| {
-            let text = tr("book.pageIndicator", "Page %s of %s")
-                .replacen("%s", &(page + 1).to_string(), 1)
-                .replacen("%s", &count.max(1).to_string(), 1);
+            // BookViewScreen.getPageNumberMessage: 26.3's en_us template is
+            // positional ("Page %1$s of %2$s").
+            let text = horizon_protocol::text::format_java(
+                &tr("book.pageIndicator", "Page %1$s of %2$s"),
+                &[(page + 1).to_string(), count.max(1).to_string()],
+            );
             let tw = HudBatch::text_width(atlas, &text);
             batch.text(atlas, &text, left + 148.0 - tw, top + 16.0, BLACK, false);
         };
@@ -1195,7 +1262,7 @@ impl Game<'_> {
             } => {
                 indicator(batch, *page, pages.len());
                 if let Some(text) = pages.get(*page) {
-                    for (i, line) in self.book_lines(text).iter().take(LINES).enumerate() {
+                    for (i, line) in self.page_lines(text).iter().take(LINES).enumerate() {
                         batch.text_styled(
                             atlas,
                             line,
diff --git a/crates/horizon-client/src/game/bundles.rs b/crates/horizon-client/src/game/bundles.rs
new file mode 100644
index 000000000..198964803
--- /dev/null
+++ b/crates/horizon-client/src/game/bundles.rs
@@ -0,0 +1,103 @@
+//! `BundleMouseActions`: the wheel over a bundle in a container screen selects
+//! one of the items it shows, which a click that takes one out of it then takes
+//! (`BundleContents.Mutable.removeOne`). Moving off the bundle clears the
+//! selection. On a server the selection is sent to it (`ServerboundSelectBundleItemPacket`).
+use super::{Game, Screen};
+use horizon_client::{
+    bundle::{Contents, toggle_selected},
+    mouse::ScrollWheelHandler,
+};
+use horizon_protocol::packets::play::{self, Serverbound as S};
+
+#[derive(Default)]
+pub(super) struct BundleMouse {
+    wheel: ScrollWheelHandler,
+    /// The slot under the cursor at the last tick (`AbstractContainerScreen.hoveredSlot`).
+    hovered: Option<usize>,
+}
+
+impl Game<'_> {
+    /// A slot a bundle can be selected in: the player's inventory, the off hand and a
+    /// container's own slots. A server only knows these in the inventory and chest-like menus.
+    fn bundle_slot(&mut self, slot: usize) -> bool {
+        (slot < 36 || slot == 504 || (300..500).contains(&slot))
+            && (self.remote.is_none() || self.remote_storage_open())
+            && (slot < 36 || slot == 504 || self.slots().contains(&slot))
+    }
+
+    /// `BundleMouseActions.onMouseScrolled`: the wheel over a bundle moves the selection
+    /// through the items its tooltip shows. True when the bundle took the wheel.
+    pub(super) fn bundle_scroll(&mut self, x: f64, y: f64) -> bool {
+        let Some(slot) = self.inventory_target().0 else {
+            return false;
+        };
+        if !self.bundle_slot(slot) {
+            return false;
+        }
+        let stack = self.slot_mut(slot).clone();
+        let items = self.res.items();
+        let Some(bundle) = stack.filter(|s| items.get(&s.item).is_some_and(|i| i.bundle)) else {
+            return false;
+        };
+        let shown = Contents::of(items, &bundle).map_or(0, |c| c.shown_count());
+        if shown == 0 {
+            return false;
+        }
+        let (wheel_x, wheel_y) = self.bundle_mouse.wheel.on_mouse_scroll(x, y);
+        let wheel = if wheel_y == 0 { -wheel_x } else { wheel_y };
+        if wheel != 0 {
+            let selected = bundle.data().map_or(-1, |d| d.bundle_selected.0);
+            let next = ScrollWheelHandler::next_selection(f64::from(wheel), selected, shown as i32);
+            if next != selected {
+                self.select_bundle(slot, next);
+            }
+        }
+        true
+    }
+
+    /// `BundleMouseActions.toggleSelectedBundleItem`: the stack here and, on a server, there.
+    fn select_bundle(&mut self, slot: usize, index: i32) {
+        if let Some(stack) = self.slot_mut(slot) {
+            toggle_selected(stack, index);
+        }
+        if self.remote.is_some() {
+            let (_, menu) = self.remote_menu();
+            if let Some(menu_slot) = Self::menu_slot_index(&menu, slot) {
+                self.send(S::SelectBundleItem(play::SelectBundleItem {
+                    slot: menu_slot as i32,
+                    index,
+                }));
+            }
+        }
+    }
+
+    /// `BundleMouseActions.unselectedBundleItem` for the bundle in `slot`, if it has a selection.
+    pub(super) fn unselect_bundle(&mut self, slot: usize) {
+        if !self.bundle_slot(slot) {
+            return;
+        }
+        let selected = self
+            .slot_mut(slot)
+            .as_ref()
+            .and_then(|s| s.data())
+            .is_some_and(|d| d.bundle_selected.0 >= 0);
+        if selected {
+            self.select_bundle(slot, -1);
+        }
+    }
+
+    /// `AbstractContainerScreen.onStopHovering` (and `onClose`): leaving a slot, or the
+    /// screen, clears the bundle's selection.
+    pub(super) fn tick_bundle_hover(&mut self) {
+        let now = if self.screen == Screen::Inventory {
+            self.inventory_target().0
+        } else {
+            None
+        };
+        if let Some(left) = std::mem::replace(&mut self.bundle_mouse.hovered, now)
+            && Some(left) != now
+        {
+            self.unselect_bundle(left);
+        }
+    }
+}
diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs
index 03174c009..7344c0e9d 100644
--- a/crates/horizon-client/src/game/chat.rs
+++ b/crates/horizon-client/src/game/chat.rs
@@ -695,12 +695,78 @@ impl Game<'_> {
             Some(ClickEvent::OpenFile(path)) => {
                 super::packs::open_folder(std::path::Path::new(&path));
             }
+            Some(ClickEvent::OpenUrl(url)) => self.click_url(url),
             Some(ClickEvent::SuggestCommand(command)) => {
                 if let Some(screen) = self.ui.chat_screen.as_mut() {
                     screen.suggest_command(&m, &c, &command);
                 }
             }
-            None => {}
+            // Screen.defaultHandleClickEvent: a page link means nothing in chat.
+            Some(ClickEvent::ChangePage(_)) | None => {}
+        }
+    }
+    /// `Screen.clickUrlAction`: nothing with Web Links off, else the link
+    /// opens, after the confirmation unless Prompt on Links is off.
+    pub(super) fn click_url(&mut self, url: String) {
+        if !self.settings.chat_links {
+            return;
+        }
+        if self.settings.file.bool("chatLinksPrompt") {
+            self.link_prompt = Some(url);
+        } else {
+            super::packs::open_uri(&url);
+        }
+    }
+    /// `ConfirmLinkScreen` (untrusted): the link and its warning over the
+    /// chat, answered yes to open it.
+    fn link_prompt_layout(
+        &self,
+        url: &str,
+        size: (f32, f32),
+    ) -> horizon_client::confirm_screen::Confirm {
+        let warning = Text::translate("chat.link.warning", &[]).with_color(0xFF_CCCC);
+        let message = Text::literal(url)
+            .append(Text::literal("\n"))
+            .append(warning);
+        horizon_client::confirm_screen::Confirm::new(
+            &self.gui.atlas.font,
+            size,
+            &Text::translate("chat.link.confirm", &[]),
+            &message,
+        )
+    }
+    pub(super) fn draw_link_prompt(&self, batch: &mut HudBatch) {
+        let Some(url) = &self.link_prompt else {
+            return;
+        };
+        let atlas = &self.gui.atlas;
+        let (w, h) = (batch.width, batch.height);
+        horizon_client::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true);
+        let (yes, no) = (
+            Text::translate("gui.yes", &[]),
+            Text::translate("gui.no", &[]),
+        );
+        self.link_prompt_layout(url, (w, h))
+            .draw(batch, atlas, self.cursor, [&yes, &no]);
+    }
+    /// The prompt's answer: the link opens on yes; either way the chat is back.
+    pub(super) fn answer_link_prompt(&mut self, yes: bool) {
+        if let Some(url) = self.link_prompt.take()
+            && yes
+        {
+            super::packs::open_uri(&url);
+        }
+    }
+    pub(super) fn link_prompt_click(&mut self) {
+        let Some(url) = &self.link_prompt else {
+            return;
+        };
+        let answer = self
+            .link_prompt_layout(url, self.gui_size())
+            .answer_at(self.cursor);
+        if let Some(yes) = answer {
+            self.audio.play_button_click();
+            self.answer_link_prompt(yes);
         }
     }
     /// Chat lines over the HUD (focused while the chat screen is open).
@@ -789,6 +855,11 @@ impl Game<'_> {
     pub(super) fn sync_rules(&mut self) {
         self.world.health_rules.natural_regeneration =
             self.ui.rules.bool("natural_health_regeneration");
+        // Player.isInvulnerableTo: the damage-type rules.
+        self.world.health_rules.drowning_damage = self.ui.rules.bool("drowning_damage");
+        self.world.health_rules.fall_damage = self.ui.rules.bool("fall_damage");
+        self.world.health_rules.fire_damage = self.ui.rules.bool("fire_damage");
+        self.world.health_rules.freeze_damage = self.ui.rules.bool("freeze_damage");
         use horizon_world::food::Difficulty;
         self.world.health_rules.difficulty = match self.ui.difficulty {
             0 => Difficulty::Peaceful,
@@ -801,7 +872,11 @@ impl Game<'_> {
     pub(super) fn load_world_state(&mut self) {
         self.ui.rules = GameRules::load(&self.world_root);
         self.ui.clock = WorldClock::default();
-        self.ui.difficulty = read_difficulty(&self.world_root).unwrap_or(2);
+        // PrimaryLevelData: the difficulty comes back from level.dat's difficulty_settings.
+        self.ui.difficulty = horizon_client::title::DIFFICULTIES
+            .iter()
+            .position(|d| *d == self.level.difficulty)
+            .map_or(2, |i| i as u8);
         if let Ok(bytes) = std::fs::read(self.world_root.join("data/minecraft/world_clocks.dat"))
             && let Ok(raw) = horizon_world::compression::Compression::Gzip.decode(&bytes, 1 << 20)
             && let Ok((root, _)) =
@@ -826,9 +901,9 @@ impl Game<'_> {
         self.build_registries();
         self.sync_rules();
     }
-    /// Save the clock and the difficulty beside level.dat (Level.write saves
-    /// the game rules: a second writer of game_rules.dat could leave it with
-    /// the rules loaded when the world opened).
+    /// Save the clock beside level.dat (Level.write saves the game rules: a
+    /// second writer of game_rules.dat could leave it with the rules loaded
+    /// when the world opened).
     pub(super) fn save_world_state(&mut self) {
         if self.world_root.as_os_str().is_empty() {
             return;
@@ -876,9 +951,6 @@ impl Game<'_> {
         if let Err(e) = horizon_client::save::write_dat(&path, root) {
             log::warn!("the world clocks were not written: {e}");
         }
-        if let Err(e) = write_difficulty(&self.world_root, self.ui.difficulty) {
-            log::warn!("the difficulty was not written: {e}");
-        }
     }
     /// Death message in chat (CombatTracker.getDeathMessage, as far as the
     /// cause is known to the client).
@@ -988,34 +1060,6 @@ pub fn screenshot_name(dir: &std::path::Path) -> String {
         n += 1;
     }
 }
-fn read_difficulty(world: &std::path::Path) -> Option<u8> {
-    let bytes = std::fs::read(world.join("level.dat")).ok()?;
-    let raw = horizon_world::compression::Compression::Gzip
-        .decode(&bytes, 64 << 20)
-        .ok()?;
-    let (root, _) =
-        horizon_world::nbt::read_named(&raw, horizon_world::nbt::Limits::default()).ok()?;
-    match root.tag.get("Data")?.get("Difficulty")? {
-        horizon_world::nbt::Tag::Byte(b) => Some((*b).clamp(0, 3) as u8),
-        _ => None,
-    }
-}
-/// Patch `Data.Difficulty` in level.dat (Level::write stores the default).
-fn write_difficulty(world: &std::path::Path, difficulty: u8) -> horizon_client::Result<()> {
-    use horizon_world::{compression::Compression, nbt};
-    let path = world.join("level.dat");
-    let bytes = std::fs::read(&path)?;
-    let raw = Compression::Gzip.decode(&bytes, 64 << 20)?;
-    let (mut root, _) = nbt::read_named(&raw, nbt::Limits::default()).map_err(|e| e.to_string())?;
-    if let Some(data) = root.tag.get_mut("Data")
-        && let Some(d) = data.get_mut("Difficulty")
-    {
-        *d = nbt::Tag::Byte(difficulty as i8);
-    }
-    let out = nbt::write_named(&root, nbt::Limits::default()).map_err(|e| e.to_string())?;
-    std::fs::write(&path, Compression::Gzip.encode(&out)?)?;
-    Ok(())
-}
 
 /// `IntegratedServer.getProfilePermissions` for the owner: `OWNER` (4) when
 /// commands are allowed, else `ALL` (0).
diff --git a/crates/horizon-client/src/game/client_ambient.rs b/crates/horizon-client/src/game/client_ambient.rs
index a10c6da49..1cf59733d 100644
--- a/crates/horizon-client/src/game/client_ambient.rs
+++ b/crates/horizon-client/src/game/client_ambient.rs
@@ -4,8 +4,12 @@
 //! on the game that has the window, in-frame or following a server, never on
 //! a server: nothing of them goes over the network.
 use super::Game;
+use horizon_client::blocks::RenderShape;
 use horizon_client::mobs::{MobEvent, ambient};
-use horizon_client::particles::{ParticleOptions, ParticleType};
+use horizon_client::motion::{LAVA, WATER};
+use horizon_client::particles::{ParticleEngine, ParticleOptions, ParticleType};
+use horizon_client::pose::Pose;
+use horizon_core::{geometry::Vec3, random::RandomSource};
 
 impl Game<'_> {
     pub(super) fn tick_client_ambient(&mut self) {
@@ -33,5 +37,209 @@ impl Game<'_> {
             }
         }
         self.eye_particles();
+        self.sprint_dust();
+        self.effect_swirls();
+    }
+
+    /// `Entity.baseTick`'s `spawnSprintParticle` on a client: dust of the
+    /// block under a sprinting player's feet streams back from them every
+    /// tick, for the window's own player and for the other players it sees.
+    fn sprint_dust(&mut self) {
+        // Each runner's feet, movement and supporting block.
+        let mut runners: Vec<(Vec3, Vec3, Option<[i32; 3]>)> = Vec::new();
+        // Entity.canSpawnSprintParticle.
+        if let Some(p) = self.player.as_ref()
+            && p.sprinting
+            && !p.spectator
+            && p.pose != Pose::Crouching
+            && !p.health.dead_or_dying()
+            && !p.fluids.was_touching_water
+            && !p.is_in_lava()
+            && p.fluid_height(WATER) <= 0.0
+            && p.fluid_height(LAVA) <= 0.0
+        {
+            let support = p.ground.supporting_block.map(|b| [b.x, b.y, b.z]);
+            runners.push((p.position, p.velocity, support));
+        }
+        let guests = self.lan.iter().flat_map(|host| host.models.values());
+        for m in self.mobs.iter().chain(guests) {
+            // Another player's fluids aren't known here: none where they stand.
+            let feet = [
+                m.position.x.floor() as i32,
+                m.position.y.floor() as i32,
+                m.position.z.floor() as i32,
+            ];
+            if m.extra.sprinting
+                && !m.extra.crouching
+                && m.alive()
+                && &*m.kind.id == "minecraft:player"
+                && self
+                    .res
+                    .facts()
+                    .get(self.world.block(feet[0], feet[1], feet[2]))
+                    .fluid_level
+                    == 0
+            {
+                runners.push((m.position, m.position.subtract(m.previous), None));
+            }
+        }
+        for (position, movement, support) in runners {
+            // Entity.getOnPosLegacy: getOnPos(0.2).
+            let below = (position.y - f64::from(0.2f32)).floor() as i32;
+            let tall = |game: &Self, s: [i32; 3]| {
+                let name = game.block_name(s);
+                [
+                    "minecraft:fences",
+                    "minecraft:walls",
+                    "minecraft:fence_gates",
+                ]
+                .iter()
+                .any(|tag| game.block_in_tag(tag, &name))
+            };
+            let at = match support {
+                Some(s) if tall(self, s) => s,
+                Some(s) => [s[0], below, s[2]],
+                None => [position.x.floor() as i32, below, position.z.floor() as i32],
+            };
+            let state = self.world.block(at[0], at[1], at[2]);
+            if self.res.facts().get(state).render_shape == RenderShape::Invisible {
+                continue;
+            }
+            let Some((sprite, tint)) = self.particle_sprite(state, at) else {
+                continue;
+            };
+            let width = f64::from(0.6f32);
+            let r = self.particles.random();
+            let mut x = position.x + (r.next_double() - 0.5) * width;
+            let mut z = position.z + (r.next_double() - 0.5) * width;
+            // Clamped into the block when the feet are in another column.
+            if position.x.floor() as i32 != at[0] {
+                x = x.clamp(f64::from(at[0]), f64::from(at[0]) + 1.0);
+            }
+            if position.z.floor() as i32 != at[2] {
+                z = z.clamp(f64::from(at[2]), f64::from(at[2]) + 1.0);
+            }
+            self.particles.add(
+                &ParticleOptions::block(ParticleType::Block, sprite, tint),
+                [x, position.y + 0.1, z],
+                [movement.x * -4.0, 1.5, movement.z * -4.0],
+            );
+        }
+    }
+
+    /// `LivingEntity.tickEffects` on a client: the swirls around an entity
+    /// with visible effects, from the particles its synched data lists. The
+    /// window's player has its own effects, a server's mobs and players the
+    /// list the server sent, and the mobs and guests of a game in the frame
+    /// theirs.
+    fn effect_swirls(&mut self) {
+        if let Some(p) = self.player.as_ref() {
+            let effects = &self.potions.effects.list;
+            let list: Vec<_> = effects
+                .iter()
+                .filter(|e| e.visible)
+                .filter_map(|e| effect_particle(e.id, e.ambient))
+                .collect();
+            let ambient = effects.iter().filter(|e| e.visible).all(|e| e.ambient);
+            let invisible = effects.iter().any(|e| e.id == "invisibility");
+            let size = (
+                f64::from(p.dimensions.width),
+                f64::from(p.dimensions.height),
+            );
+            swirl(
+                &mut self.particles,
+                p.position,
+                size,
+                &list,
+                ambient,
+                invisible,
+            );
+        }
+        let guests = self.lan.iter().flat_map(|host| host.models.values());
+        for m in self.mobs.iter().chain(guests) {
+            if !m.alive() {
+                continue;
+            }
+            let size = (f64::from(m.width()), f64::from(m.height()));
+            let invisible = m.invisible || m.has_effect("minecraft:invisibility");
+            if m.extra.effect_particles.is_empty() {
+                // A mob of this game: its own effects, visible and not ambient.
+                if m.extra.effects.is_empty() {
+                    continue;
+                }
+                let list: Vec<_> = m
+                    .extra
+                    .effects
+                    .iter()
+                    .filter(|e| !m.extra.hidden_effects.contains(&e.0))
+                    .filter_map(|e| effect_particle(e.0, false))
+                    .collect();
+                swirl(
+                    &mut self.particles,
+                    m.position,
+                    size,
+                    &list,
+                    false,
+                    invisible,
+                );
+            } else {
+                let list = &m.extra.effect_particles;
+                let ambient = m.extra.effect_ambient;
+                swirl(
+                    &mut self.particles,
+                    m.position,
+                    size,
+                    list,
+                    ambient,
+                    invisible,
+                );
+            }
+        }
     }
 }
+
+/// `MobEffect.particleFactory`: the omens have particles of their own, any
+/// other effect an entity effect in its colour, faint when ambient.
+pub(super) fn effect_particle(effect: &str, ambient: bool) -> Option<ParticleOptions> {
+    Some(match effect.trim_start_matches("minecraft:") {
+        "trial_omen" => ParticleOptions::simple(ParticleType::TrialOmen),
+        "raid_omen" => ParticleOptions::simple(ParticleType::RaidOmen),
+        other => {
+            let color = horizon_client::brewing::effect(other)?.color;
+            let channel = |shift: u32| ((color >> shift) & 255) as f32 / 255.0;
+            // MobEffect.AMBIENT_ALPHA is 38 of 255.
+            let alpha = if ambient { 38.0 / 255.0 } else { 1.0 };
+            ParticleOptions::colored(
+                ParticleType::EntityEffect,
+                [channel(16), channel(8), channel(0), alpha],
+            )
+        }
+    })
+}
+
+/// One tick of `LivingEntity.tickEffects`' client branch: a one in four
+/// chance (one in fifteen while invisible, a fifth of either when all the
+/// effects are ambient) of one of the particles at a random spot of the box.
+fn swirl(
+    particles: &mut ParticleEngine,
+    feet: Vec3,
+    size: (f64, f64),
+    list: &[ParticleOptions],
+    ambient: bool,
+    invisible: bool,
+) {
+    if list.is_empty() {
+        return;
+    }
+    let bound = if invisible { 15 } else { 4 } * if ambient { 5 } else { 1 };
+    let r = particles.random();
+    let Ok(0) = r.next_int_bound(bound) else {
+        return;
+    };
+    // Util.getRandom, then getRandomX(0.5), getRandomY and getRandomZ.
+    let pick = r.next_int_bound(list.len() as i32).unwrap_or_default() as usize;
+    let x = feet.x + size.0 * (2.0 * r.next_double() - 1.0) * 0.5;
+    let y = feet.y + size.1 * r.next_double();
+    let z = feet.z + size.0 * (2.0 * r.next_double() - 1.0) * 0.5;
+    particles.add(&list[pick], [x, y, z], [1.0; 3]);
+}
diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs
index 106e0e1a1..f125899f3 100644
--- a/crates/horizon-client/src/game/combat.rs
+++ b/crates/horizon-client/src/game/combat.rs
@@ -1,7 +1,16 @@
 //! The player's `CombatTracker`: the damage taken lately, who dealt it and
 //! where the player fell from, turned into the vanilla death message.
 use super::{Game, chat::PLAYER_NAME};
-use horizon_client::{health::HealthEvent, motion::MotionEvent, text::Text};
+use horizon_client::{
+    health::HealthEvent,
+    motion::MotionEvent,
+    particles::{ParticleOptions, ParticleType},
+    text::Text,
+};
+use horizon_core::random::RandomSource;
+
+/// `EntityEvent.DROWN_PARTICLES`: broadcast with the drowning damage.
+pub(super) const DROWN_EVENT: i8 = 67;
 
 struct Entry {
     damage_type: String,
@@ -10,6 +19,9 @@ struct Entry {
     fall_distance: f32,
     /// The causing entity: its id (for comparisons) and display name.
     attacker: Option<(u32, Text)>,
+    /// The direct entity's display name when no entity caused the damage
+    /// (`DamageSource.directEntity`: a potion with no thrower, a cloud).
+    direct: Option<Text>,
 }
 #[derive(Default)]
 pub(super) struct CombatTracker {
@@ -19,6 +31,8 @@ pub(super) struct CombatTracker {
     /// Attackers of damage dealt this tick, claimed by the matching
     /// `RecordedDamage` event.
     pending: Vec<(String, (u32, Text))>,
+    /// `pending` for a direct entity with no causing entity: only its name.
+    pending_direct: Vec<(String, Text)>,
     /// `LivingEntity.lastHurtByMob` and its timestamp (the kill credit).
     last_hurt_by: Option<((u32, Text), i64)>,
     /// The mob the player last hurt (`getLastHurtMob`) and when.
@@ -31,11 +45,54 @@ pub(super) struct CombatTracker {
     /// The mob exploding now (`ServerExplosion.source`): its team's friendly
     /// fire decides whom the blast may hurt.
     pub(super) explosion_source: Option<u32>,
+    /// The blast now going off comes from a primed TNT, creeper, wither
+    /// skull, wither or TNT minecart, the sources that empty a hive they
+    /// destroy (`BeehiveBlock.getDrops`).
+    pub(super) hive_emptying_blast: bool,
+    /// The mob that owns the projectile exploding now (`getIndirectSourceEntity`):
+    /// the mobs the blast hurts record it as their attacker.
+    pub(super) explosion_owner: Option<u32>,
+    /// Charged creepers whose blast just went off and that have not dropped
+    /// a head yet (`Creeper.droppedSkulls`): they are gone from the mob list,
+    /// but the mobs they killed still ask for their loot.
+    pub(super) charged_exploders: Vec<u32>,
     /// The player's fall distance before this tick's movement (as of the
     /// end of the last one).
     fall_before: f64,
 }
 impl Game<'_> {
+    /// `LivingEntity.makeDrownParticles`: eight bubbles around the entity,
+    /// moving with it.
+    pub(super) fn drown_particles(&mut self, at: [f64; 3], velocity: [f64; 3]) {
+        let bubble = ParticleOptions::simple(ParticleType::Bubble);
+        for _ in 0..8 {
+            let mut triangle = || {
+                let r = self.particles.random();
+                r.next_double() - r.next_double()
+            };
+            let p = [at[0] + triangle(), at[1] + triangle(), at[2] + triangle()];
+            self.particles.add(&bubble, p, velocity);
+        }
+    }
+    /// Entity event 67 from a server, for this client's own player or an
+    /// entity it draws.
+    pub(super) fn remote_drown(&mut self, id: i32) {
+        let own = self.remote.as_ref().is_some_and(|r| r.entity_id == id);
+        let body = if own {
+            self.player.as_ref().map(|p| {
+                let (at, v) = (p.position, p.velocity);
+                ([at.x, at.y, at.z], [v.x, v.y, v.z])
+            })
+        } else {
+            self.mobs.iter().find(|m| m.id == id as u32).map(|m| {
+                let (at, v) = (m.position, m.velocity);
+                ([at.x, at.y, at.z], [v.x, v.y, v.z])
+            })
+        };
+        if let Some((at, v)) = body {
+            self.drown_particles(at, v);
+        }
+    }
     /// The display name of a mob: its custom name or its type's name.
     pub(super) fn mob_display_name(&self, id: u32) -> Option<Text> {
         let m = self.mobs.iter().find(|m| m.id == id)?;
@@ -62,17 +119,38 @@ impl Game<'_> {
             .pending
             .push((damage_type.to_owned(), (id, name)));
     }
+    /// The `DamageSource.directEntity` of the next `damage_type` damage when
+    /// nothing caused it (a splash potion nobody threw): the death message
+    /// names it instead (`getLocalizedDeathMessage`). It is no kill credit.
+    pub(super) fn note_direct_entity(&mut self, damage_type: &str, name: Text) {
+        self.combat
+            .pending_direct
+            .push((damage_type.to_owned(), name));
+    }
     /// `LivingEntity.handleDamageEvent` for the player: the hurt sound of the
     /// source's `DamageEffects` (`Player.getHurtSound`).
     pub(super) fn player_hurt_sound(&mut self, sound: &str, at: [f64; 3]) {
-        let pitch = self.audio.hurt_pitch();
-        self.audio.play(sound, Some(at), 1.0, pitch);
+        // Player.getVoicePitch: always 1.0.
+        self.audio.play(sound, Some(at), 1.0, 1.0);
     }
     /// `CombatTracker.recordDamage` for the motion events of this tick.
     pub(super) fn record_combat(&mut self, events: &[MotionEvent]) {
         self.recheck_combat();
         for e in events {
             let (name, amount) = match e {
+                // LivingEntity.getDamageAfterMagicAbsorb (Resistance) and
+                // Player.actuallyHurt (absorption hearts) and
+                // LivingEntity.hurtServer (the shield, only for an accepted
+                // hit), in tenths.
+                MotionEvent::Health(HealthEvent::Statistic { name, amount }) => {
+                    match *name {
+                        "resisted" => self.stats.custom("damage_resisted", *amount),
+                        "absorbed" => self.stats.custom("damage_absorbed", *amount),
+                        "blocked" => self.stats.custom("damage_blocked_by_shield", *amount),
+                        _ => {}
+                    }
+                    continue;
+                }
                 MotionEvent::Health(HealthEvent::RecordedDamage { source, amount }) => {
                     let Some(d) = self.motion.health.damage.definition(*source) else {
                         continue;
@@ -90,6 +168,15 @@ impl Game<'_> {
                 .iter()
                 .position(|(t, _)| *t == name)
                 .map(|i| self.combat.pending.remove(i).1);
+            let direct = match attacker {
+                Some(_) => None,
+                None => self
+                    .combat
+                    .pending_direct
+                    .iter()
+                    .position(|(t, _)| *t == name)
+                    .map(|i| self.combat.pending_direct.remove(i).1),
+            };
             let (fall_location, fall_distance) = self.fall_location();
             let now = self.world.game_time;
             if let Some(a) = &attacker {
@@ -107,10 +194,16 @@ impl Game<'_> {
                 fall_location,
                 fall_distance,
                 attacker,
+                direct,
             });
             self.combat.last_damage = now;
+            // InfestedMobEffect.onMobHurt.
+            if self.potions.effects.get("infested").is_some() {
+                self.player_infested();
+            }
         }
         self.combat.pending.clear();
+        self.combat.pending_direct.clear();
         self.combat.fall_before = self.player.as_ref().map_or(0.0, |p| p.fall_distance);
     }
     /// `FallLocation.getCurrentFallLocation` and the fall distance so far.
@@ -220,6 +313,7 @@ impl Game<'_> {
         let entries = std::mem::take(&mut self.combat.entries);
         let killing = entries.last().expect("checked above");
         let killer = killing.attacker.clone();
+        let direct = killing.direct.clone();
         if def.1 == "fall_variants"
             && let Some(knock) = knock.and_then(|i| entries.get(i))
         {
@@ -244,15 +338,22 @@ impl Game<'_> {
                 .append(Text::literal("]"));
             return Text::translate(&format!("{key}.message"), &[me, link]);
         }
+        // `getLocalizedDeathMessage`: the causing entity's name, or the
+        // direct entity's when nothing caused the damage.
         if let Some((_, name)) = killer {
             return Text::translate(&key, &[me, name]);
         }
+        if let Some(name) = direct {
+            return Text::translate(&key, &[me, name]);
+        }
         // getKillCredit: the last mob that hurt the player in the past 100 ticks.
         if let Some(((_, name), at)) = &self.combat.last_hurt_by
             && self.world.game_time - at <= 100
         {
             return Text::translate(&format!("{key}.player"), &[me, name.clone()]);
         }
+        // No entity at all: the one-argument message, as vanilla sends it (a
+        // template that names a killer then shows as written).
         Text::translate(&key, &[me])
     }
 }
diff --git a/crates/horizon-client/src/game/command_blocks.rs b/crates/horizon-client/src/game/command_blocks.rs
index 76fc6d48c..868346452 100644
--- a/crates/horizon-client/src/game/command_blocks.rs
+++ b/crates/horizon-client/src/game/command_blocks.rs
@@ -2,7 +2,7 @@
 //! tick (`execute`, `executeChain`), `BaseCommandBlock.performCommand`
 //! through the command system with the block's output, and
 //! `CommandBlockEditScreen` with what `handleSetCommandBlock` does with it.
-use super::{Game, Screen, commands::execute::Source};
+use super::{Game, Screen, commands::execute::Source, lan::LanHost};
 use horizon_client::{
     command_block::{self, CommandBlock, Mode},
     containers::BlockEntity,
@@ -12,6 +12,7 @@ use horizon_client::{
     world::World,
 };
 use horizon_core::position::BlockPos;
+use horizon_protocol::packets::play::{self, Serverbound as S};
 use horizon_world::{
     chunk::BlockState,
     level::flags,
@@ -35,6 +36,16 @@ pub(super) struct CommandBlockScreen {
     auto: bool,
 }
 
+/// What `ServerboundSetCommandBlockPacket` carries.
+struct CommandBlockEdit {
+    pos: Pos,
+    command: String,
+    track_output: bool,
+    mode: Mode,
+    conditional: bool,
+    auto: bool,
+}
+
 #[derive(Clone, Copy, PartialEq)]
 enum Button {
     Output,
@@ -186,6 +197,18 @@ impl Game<'_> {
     pub(super) fn can_use_game_master_blocks(&self) -> bool {
         self.creative && self.ui.registries.permission >= 2
     }
+    /// `CommandBlock.useWithoutItem` on a server's client, which opens the
+    /// screen itself (`Player.openCommandBlock`) while the server only
+    /// answers the click: the block at `pos`, when it is a command block the
+    /// player may edit.
+    pub(super) fn open_command_block_if_editable(&mut self, pos: Pos) {
+        let is_command_block = self
+            .block_state_at(pos)
+            .is_some_and(|state| Mode::of_block(&state.name).is_some());
+        if is_command_block && self.can_use_game_master_blocks() {
+            self.open_command_block(pos);
+        }
+    }
     fn command_block(&self, pos: Pos) -> Option<&CommandBlock> {
         match self.world.block_entities.get(&pos)? {
             BlockEntity::CommandBlock(c) => Some(c),
@@ -572,12 +595,66 @@ impl Game<'_> {
             s.command.insert_text(&allowed);
         }
     }
-    /// `ServerGamePacketListenerImpl.handleSetCommandBlock`.
+    /// The edit screen's Done: a server's client sends the packet, the
+    /// window's own world applies it (`handleSetCommandBlock`).
     fn set_command_block(&mut self, s: &CommandBlockScreen) {
         if !self.can_use_game_master_blocks() {
             self.system_message(Text::translate("advMode.notAllowed", &[]));
             return;
         }
+        let edit = CommandBlockEdit {
+            pos: s.pos,
+            command: s.command.value.clone(),
+            track_output: s.track_output,
+            mode: s.mode,
+            conditional: s.conditional,
+            auto: s.auto,
+        };
+        if self.remote.is_some() {
+            self.send(S::SetCommandBlock(play::SetCommandBlock {
+                pos: [edit.pos.0, edit.pos.1, edit.pos.2],
+                command: edit.command,
+                mode: edit.mode.ordinal(),
+                flags: i8::from(edit.track_output)
+                    | (i8::from(edit.conditional) << 1)
+                    | (i8::from(edit.auto) << 2),
+            }));
+        } else {
+            self.apply_command_block(&edit);
+        }
+    }
+    /// `ServerGamePacketListenerImpl.handleSetCommandBlock` for a guest: the
+    /// block is edited only by a creative player with game master commands.
+    pub(super) fn lan_set_command_block(
+        &mut self,
+        host: &mut LanHost,
+        conn: u32,
+        p: play::SetCommandBlock,
+    ) {
+        let Some(g) = host.hub.guest(conn) else {
+            return;
+        };
+        let allowed = g.creative() && g.permission >= 2;
+        let edit = CommandBlockEdit {
+            pos: (p.pos[0], p.pos[1], p.pos[2]),
+            command: p.command,
+            track_output: p.flags & 1 != 0,
+            mode: Mode::from_ordinal(p.mode),
+            conditional: p.flags & 2 != 0,
+            auto: p.flags & 4 != 0,
+        };
+        self.as_guest(host, conn, |game| {
+            if allowed {
+                game.apply_command_block(&edit);
+                // BaseCommandBlock.onUpdated: the clients get the new command.
+                game.mark_block_entity_updated(edit.pos);
+            } else {
+                game.system_message(Text::translate("advMode.notAllowed", &[]));
+            }
+        });
+    }
+    /// What `handleSetCommandBlock` does once the player may edit the block.
+    fn apply_command_block(&mut self, s: &CommandBlockEdit) {
         let pos = s.pos;
         let registry = self.pack.assets.registry;
         let Some(current) = self.block_state_at(pos) else {
@@ -609,7 +686,7 @@ impl Game<'_> {
             }
             let _ = self.process_level_events();
         }
-        let command = s.command.value.clone();
+        let command = s.command.clone();
         let Some(c) = command_block_mut(&mut self.world, pos) else {
             return;
         };
diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs
index 8f934ad8a..43cdfa51c 100644
--- a/crates/horizon-client/src/game/commands.rs
+++ b/crates/horizon-client/src/game/commands.rs
@@ -42,9 +42,10 @@ pub(super) enum Target {
     Guest(u32),
     Mob(u32),
     Item(u32),
-    Orb(usize),
-    /// By index in `creatures.projectiles`.
-    Projectile(usize),
+    /// An experience orb, by its entity id.
+    Orb(u32),
+    /// A projectile, by its entity id.
+    Projectile(u32),
     Stand(u32),
     Frame(u32),
     Painting(u32),
@@ -53,6 +54,10 @@ pub(super) enum Target {
     /// An entity of a type Horizon does not simulate (markers, displays,
     /// interactions...): kept as its saved data at a position.
     Other(u32),
+    /// An End crystal, by its entity id (`minecraft:end_crystal`).
+    Crystal(u32),
+    /// The Ender Dragon, by its entity id (`minecraft:ender_dragon`).
+    Dragon(u32),
 }
 /// An entity of a type Horizon does not simulate: its compound lives in the
 /// entity memory (`persist.raw`), its position and rotation here.
@@ -340,14 +345,16 @@ impl Game<'_> {
                 .iter()
                 .find(|i| i.id == id)
                 .map(|i| [i.position.x, i.position.y, i.position.z]),
-            Target::Orb(i) => self
+            Target::Orb(id) => self
                 .orbs
-                .get(i)
+                .iter()
+                .find(|o| o.id == id)
                 .map(|o| [o.position.x, o.position.y, o.position.z]),
-            Target::Projectile(i) => self
+            Target::Projectile(id) => self
                 .creatures
                 .projectiles
-                .get(i)
+                .iter()
+                .find(|a| a.id == id)
                 .map(|a| [a.position.x, a.position.y, a.position.z]),
             Target::Stand(id) => self
                 .armor_stands
@@ -385,6 +392,16 @@ impl Game<'_> {
                 .iter()
                 .find(|o| o.id == id)
                 .map(|o| [o.position.x, o.position.y, o.position.z]),
+            Target::Crystal(id) => self
+                .crystals
+                .iter()
+                .find(|c| c.id == id)
+                .map(|c| [c.position.x, c.position.y, c.position.z]),
+            Target::Dragon(id) => self
+                .dragon
+                .as_ref()
+                .filter(|d| d.id == id)
+                .map(|d| [d.position.x, d.position.y, d.position.z]),
         }
     }
     pub(super) fn target_type(&self, t: Target) -> String {
@@ -399,10 +416,11 @@ impl Game<'_> {
                 }),
             Target::Item(_) => "minecraft:item".into(),
             Target::Orb(_) => "minecraft:experience_orb".into(),
-            Target::Projectile(i) => self
+            Target::Projectile(id) => self
                 .creatures
                 .projectiles
-                .get(i)
+                .iter()
+                .find(|p| p.id == id)
                 .map_or_else(String::new, |p| p.kind.id().into()),
             Target::Stand(_) => "minecraft:armor_stand".into(),
             Target::Frame(id) => {
@@ -428,6 +446,8 @@ impl Game<'_> {
                 .iter()
                 .find(|o| o.id == id)
                 .map_or_else(String::new, |o| o.kind.clone()),
+            Target::Crystal(_) => "minecraft:end_crystal".into(),
+            Target::Dragon(_) => "minecraft:ender_dragon".into(),
         }
     }
     /// The name of the player the game acts for: a guest's own while their
@@ -512,51 +532,72 @@ impl Game<'_> {
                 s.pos[2].unwrap_or(p[2]),
             ]
         };
-        let mut candidates: Vec<Target> = Vec::new();
+        let mut source_candidates: Vec<Target> = Vec::new();
         match (s.kind, self.command_source) {
             // @s: the executing entity (none for a server source).
-            ('s', Some(source)) => candidates.extend(source.entity),
-            ('s', None) => candidates.extend(self.source_entity()),
+            ('s', Some(source)) => source_candidates.extend(source.entity),
+            ('s', None) => source_candidates.extend(self.source_entity()),
             // A guest in place is among the players, in join order.
             _ if self.player.is_some() && self.lan_acting.is_none() => {
-                candidates.push(Target::Player);
+                source_candidates.push(Target::Player);
             }
             _ => {}
         }
         if s.kind != 's' {
-            use horizon_client::projectiles::ProjectileKind as K;
-            candidates.extend(self.player_candidates(s));
-            candidates.extend(
-                self.mobs
-                    .iter()
-                    .filter(|m| m.death_time == 0)
-                    .map(|m| Target::Mob(m.id)),
-            );
-            candidates.extend(self.dropped.iter().map(|i| Target::Item(i.id)));
-            candidates.extend((0..self.orbs.len()).map(Target::Orb));
-            candidates.extend(
-                self.creatures
-                    .projectiles
-                    .iter()
-                    .enumerate()
-                    // The kinds /data can write (entity_nbt).
-                    .filter(|(_, p)| {
-                        p.arrow.is_some()
-                            || matches!(p.kind, K::LargeFireball { .. } | K::SmallFireball)
-                    })
-                    .map(|(i, _)| Target::Projectile(i)),
-            );
-            candidates.extend(self.armor_stands.iter().map(|a| Target::Stand(a.id)));
-            candidates.extend(self.item_frames.iter().map(|f| Target::Frame(f.id)));
-            candidates.extend(self.paintings.iter().map(|p| Target::Painting(p.id)));
-            candidates.extend(self.boats.iter().map(|b| Target::Boat(b.id)));
-            candidates.extend(self.carts.iter().map(|c| Target::Cart(c.id)));
-            candidates.extend(self.others.iter().map(|o| Target::Other(o.id)));
+            source_candidates.extend(self.player_candidates(s));
         }
+        let source_dim = self.dim;
+        // A selector with a spatial constraint reaches the level the command
+        // runs in only; an unbounded one reaches every loaded level
+        // (EntitySelector.findEntities).
+        let dims = if s.world_limited() {
+            vec![source_dim]
+        } else {
+            self.loaded_dims()
+        };
+        let mut out: Vec<(Target, f64)> = Vec::new();
+        for dim in dims {
+            let back = self.enter_command_level(dim);
+            let mut candidates = Vec::new();
+            if dim == source_dim {
+                candidates.append(&mut source_candidates);
+            }
+            if s.kind != 's' {
+                candidates.extend(self.level_candidates());
+            }
+            out.extend(self.select_in_level(candidates, s, origin));
+            if let Some(back) = back {
+                self.enter_command_level(back);
+            }
+        }
+        match s.sort {
+            Sort::Nearest => out.sort_by(|a, b| a.1.total_cmp(&b.1)),
+            Sort::Furthest => out.sort_by(|a, b| b.1.total_cmp(&a.1)),
+            Sort::Random => {
+                for i in (1..out.len()).rev() {
+                    let j = self.world.random.next_int_bound(i as i32 + 1).unwrap_or(0) as usize;
+                    out.swap(i, j);
+                }
+            }
+            Sort::Arbitrary => {}
+        }
+        out.into_iter()
+            .take(s.limit.max(1))
+            .map(|(t, _)| t)
+            .collect()
+    }
+    /// The candidates of the level in place that pass the selector
+    /// (EntitySelector.getPredicate).
+    fn select_in_level(
+        &mut self,
+        candidates: Vec<Target>,
+        s: &Selector,
+        origin: [f64; 3],
+    ) -> Vec<(Target, f64)> {
         let level = self.experience.level;
         let creative = self.creative;
         let passing = self.selector_extra_filter(&candidates, s);
-        let mut out: Vec<(Target, f64)> = candidates
+        candidates
             .into_iter()
             .filter_map(|t| {
                 let p = self.target_position(t)?;
@@ -628,23 +669,102 @@ impl Game<'_> {
                 }
                 Some((t, d2))
             })
-            .collect();
-        match s.sort {
-            Sort::Nearest => out.sort_by(|a, b| a.1.total_cmp(&b.1)),
-            Sort::Furthest => out.sort_by(|a, b| b.1.total_cmp(&a.1)),
-            Sort::Random => {
-                for i in (1..out.len()).rev() {
-                    let j = self.world.random.next_int_bound(i as i32 + 1).unwrap_or(0) as usize;
-                    out.swap(i, j);
-                }
-            }
-            Sort::Arbitrary => {}
-        }
-        out.into_iter()
-            .take(s.limit.max(1))
-            .map(|(t, _)| t)
             .collect()
     }
+    /// The entities of the level in place a selector can find.
+    fn level_candidates(&self) -> Vec<Target> {
+        use horizon_client::projectiles::ProjectileKind as K;
+        let mut candidates = Vec::new();
+        candidates.extend(
+            self.mobs
+                .iter()
+                .filter(|m| m.death_time == 0)
+                .map(|m| Target::Mob(m.id)),
+        );
+        candidates.extend(self.dropped.iter().map(|i| Target::Item(i.id)));
+        candidates.extend(self.orbs.iter().map(|o| Target::Orb(o.id)));
+        candidates.extend(
+            self.creatures
+                .projectiles
+                .iter()
+                // The kinds /data can write (entity_nbt).
+                .filter(|p| {
+                    p.is_arrow() || matches!(p.kind, K::LargeFireball { .. } | K::SmallFireball)
+                })
+                .map(|p| Target::Projectile(p.id)),
+        );
+        candidates.extend(self.armor_stands.iter().map(|a| Target::Stand(a.id)));
+        candidates.extend(self.item_frames.iter().map(|f| Target::Frame(f.id)));
+        candidates.extend(self.paintings.iter().map(|p| Target::Painting(p.id)));
+        candidates.extend(self.boats.iter().map(|b| Target::Boat(b.id)));
+        candidates.extend(self.carts.iter().map(|c| Target::Cart(c.id)));
+        candidates.extend(self.others.iter().map(|o| Target::Other(o.id)));
+        // The End crystals and the dragon (EndCrystal and EnderDragon
+        // are entities of their own).
+        candidates.extend(self.crystals.iter().map(|c| Target::Crystal(c.id)));
+        if let Some(d) = &self.dragon {
+            candidates.push(Target::Dragon(d.id));
+        }
+        candidates
+    }
+    /// The loaded levels, in the order the server holds them: the
+    /// overworld, the nether, the end (MinecraftServer.getAllLevels).
+    fn loaded_dims(&self) -> Vec<Dim> {
+        let mut dims = vec![self.dim];
+        dims.extend(self.levels.parked_dims());
+        dims.sort_by_key(|d| match d {
+            Dim::Overworld => 0,
+            Dim::Nether => 1,
+            Dim::End => 2,
+        });
+        dims
+    }
+    /// Whether the level in place holds the entity a target names.
+    fn level_holds(&self, t: Target) -> bool {
+        match t {
+            // A player is in no level of its own.
+            Target::Player | Target::Guest(_) => true,
+            Target::Mob(id) => self.mobs.iter().any(|m| m.id == id),
+            Target::Item(id) => self.dropped.iter().any(|i| i.id == id),
+            Target::Orb(id) => self.orbs.iter().any(|o| o.id == id),
+            Target::Projectile(id) => self.creatures.projectiles.iter().any(|p| p.id == id),
+            Target::Stand(id) => self.armor_stands.iter().any(|a| a.id == id),
+            Target::Frame(id) => self.item_frames.iter().any(|f| f.id == id),
+            Target::Painting(id) => self.paintings.iter().any(|p| p.id == id),
+            Target::Boat(id) => self.boats.iter().any(|b| b.id == id),
+            Target::Cart(id) => self.carts.iter().any(|c| c.id == id),
+            Target::Other(id) => self.others.iter().any(|o| o.id == id),
+            Target::Crystal(id) => self.crystals.iter().any(|c| c.id == id),
+            Target::Dragon(id) => self.dragon.as_ref().is_some_and(|d| d.id == id),
+        }
+    }
+    /// Run `f` with the level that holds the entity a target names in place
+    /// (the entity ids are unique across the loaded levels) and put the
+    /// level back afterwards. `f` does not run when no level holds the
+    /// entity.
+    pub(in crate::game) fn in_target_level<R>(
+        &mut self,
+        t: Target,
+        f: impl FnOnce(&mut Self) -> R,
+    ) -> Option<R> {
+        if self.level_holds(t) {
+            return Some(f(self));
+        }
+        for dim in self.levels.parked_dims() {
+            let back = self.enter_command_level(dim);
+            if self.level_holds(t) {
+                let r = f(self);
+                if let Some(back) = back {
+                    self.enter_command_level(back);
+                }
+                return Some(r);
+            }
+            if let Some(back) = back {
+                self.enter_command_level(back);
+            }
+        }
+        None
+    }
     fn entity_tag_matches(&self, tag: &str, ty: &str) -> bool {
         let path = self.options.resources.join(format!(
             "data/minecraft/tags/entity_type/{}.json",
@@ -1104,6 +1224,10 @@ impl Game<'_> {
         Ok(targets.len() as i32)
     }
     fn teleport_to(&mut self, t: Target, pos: [f64; 3], rotation: Option<[f32; 2]>) {
+        // An entity in another level is teleported in the level that holds it.
+        let _ = self.in_target_level(t, |g| g.teleport_to_in_level(t, pos, rotation));
+    }
+    fn teleport_to_in_level(&mut self, t: Target, pos: [f64; 3], rotation: Option<[f32; 2]>) {
         let v = Vec3::new(pos[0], pos[1], pos[2]);
         match t {
             Target::Guest(_) => {
@@ -1152,14 +1276,14 @@ impl Game<'_> {
                     i.previous = v;
                 }
             }
-            Target::Orb(i) => {
-                if let Some(o) = self.orbs.get_mut(i) {
+            Target::Orb(id) => {
+                if let Some(o) = self.orbs.iter_mut().find(|o| o.id == id) {
                     o.position = v;
                     o.previous = v;
                 }
             }
-            Target::Projectile(i) => {
-                if let Some(a) = self.creatures.projectiles.get_mut(i) {
+            Target::Projectile(id) => {
+                if let Some(a) = self.creatures.projectiles.iter_mut().find(|a| a.id == id) {
                     a.position = v;
                     a.previous = v;
                 }
@@ -1199,6 +1323,17 @@ impl Game<'_> {
                     }
                 }
             }
+            Target::Crystal(id) => {
+                if let Some(c) = self.crystals.iter_mut().find(|c| c.id == id) {
+                    c.position = v;
+                }
+            }
+            Target::Dragon(id) => {
+                if let Some(d) = self.dragon.as_mut().filter(|d| d.id == id) {
+                    d.position = v;
+                    d.previous = v;
+                }
+            }
             // Wall-mounted entities do not move.
             Target::Frame(_) | Target::Painting(_) => {}
         }
@@ -1558,6 +1693,10 @@ impl Game<'_> {
         Ok(duration.unwrap_or(-1))
     }
     fn kill_target(&mut self, t: Target) {
+        // An entity in another level is killed in the level that holds it.
+        let _ = self.in_target_level(t, |g| g.kill_target_in_level(t));
+    }
+    fn kill_target_in_level(&mut self, t: Target) {
         match t {
             Target::Guest(_) => {
                 self.for_player(t, |g| g.kill_target(Target::Player));
@@ -1577,16 +1716,13 @@ impl Game<'_> {
                 }
             }
             Target::Item(id) => self.dropped.retain(|i| i.id != id),
-            Target::Orb(i) => {
-                if i < self.orbs.len() {
-                    self.orbs[i].age = u32::MAX / 2;
+            Target::Orb(id) => {
+                if let Some(o) = self.orbs.iter_mut().find(|o| o.id == id) {
+                    o.age = u32::MAX / 2;
                 }
             }
-            // cmd_kill goes from the highest index down.
-            Target::Projectile(i) => {
-                if i < self.creatures.projectiles.len() {
-                    self.creatures.projectiles.remove(i);
-                }
+            Target::Projectile(id) => {
+                self.creatures.projectiles.retain(|p| p.id != id);
             }
             Target::Stand(id) => self.armor_stands.retain(|a| a.id != id),
             Target::Frame(id) => self.item_frames.retain(|f| f.id != id),
@@ -1594,7 +1730,11 @@ impl Game<'_> {
             Target::Boat(id) => self.boats.retain(|b| b.id != id),
             Target::Cart(id) => self.carts.retain(|c| c.id != id),
             Target::Other(id) => self.others.retain(|o| o.id != id),
+            Target::Crystal(id) => self.kill_crystal(id),
+            Target::Dragon(id) => self.kill_dragon(id),
         }
+        // The orbs marked for removal are gone (Entity.kill removes them).
+        self.orbs.retain(|o| o.age < u32::MAX / 2);
     }
     fn cmd_kill(&mut self, ctx: &Context) -> R<i32> {
         let targets = if ctx.get("targets").is_some() {
@@ -1602,19 +1742,18 @@ impl Game<'_> {
         } else {
             vec![self.implied_player()]
         };
-        let names: Vec<Text> = targets.iter().map(|&t| self.target_name(t)).collect();
-        // Remove indexed entities from the back so earlier indices stay valid.
-        let mut ordered = targets.clone();
-        ordered.sort_by_key(|t| {
-            std::cmp::Reverse(match t {
-                Target::Orb(i) | Target::Projectile(i) => *i,
-                _ => 0,
-            })
-        });
-        for t in ordered {
+        let mut names: Vec<Text> = Vec::new();
+        for &t in &targets {
+            // The name of an entity in another level is read there.
+            let name = match self.in_target_level(t, |g| g.target_name(t)) {
+                Some(name) => name,
+                None => self.target_name(t),
+            };
+            names.push(name);
+        }
+        for &t in &targets {
             self.kill_target(t);
         }
-        self.orbs.retain(|o| o.age < u32::MAX / 2);
         let message = if targets.len() == 1 {
             Text::translate("commands.kill.success.single", &[names[0].clone()])
         } else {
@@ -1697,6 +1836,8 @@ impl Game<'_> {
                         value: 0,
                         age: 0,
                         on_ground: false,
+                        count: 1,
+                        ticks: 0,
                     });
                     name = Text::translate("entity.minecraft.experience_orb", &[]);
                 }
@@ -1704,6 +1845,20 @@ impl Game<'_> {
                     self.spawn_bolt(pos, false);
                     name = Text::translate("entity.minecraft.lightning_bolt", &[]);
                 }
+                "end_crystal" => {
+                    // EndCrystal's constructor takes an id from the entity
+                    // counter, and the crystal is shown with its base.
+                    self.next_entity += 1;
+                    self.crystals.push(super::dragon::Crystal {
+                        id: self.next_entity,
+                        position: Vec3::new(pos[0], pos[1], pos[2]),
+                        show_bottom: true,
+                        time: self.world.random.next_int_bound(100_000).unwrap_or(0),
+                        beam: None,
+                        invulnerable: false,
+                    });
+                    name = Text::translate("entity.minecraft.end_crystal", &[]);
+                }
                 k if super::minecarts::CartKind::from_id(&kind).is_some() => {
                     let cart_kind = super::minecarts::CartKind::from_id(&kind)
                         .unwrap_or(super::minecarts::CartKind::Rideable);
@@ -1894,8 +2049,7 @@ impl Game<'_> {
             return false;
         }
         self.world.block_entities.insert(key, new);
-        let state = self.world.block(pos[0], pos[1], pos[2]);
-        let _ = self.world.set(pos[0], pos[1], pos[2], state);
+        self.world.modified.insert((pos[0] >> 4, pos[2] >> 4));
         true
     }
     /// RandomizableContainer.tryLoadLootTable for a tag a command gives a
diff --git a/crates/horizon-client/src/game/commands/data.rs b/crates/horizon-client/src/game/commands/data.rs
index ac16c5e7c..61bf3abe9 100644
--- a/crates/horizon-client/src/game/commands/data.rs
+++ b/crates/horizon-client/src/game/commands/data.rs
@@ -31,8 +31,13 @@ fn set_key(tag: &mut Tag, key: &str, value: Tag) {
 impl Game<'_> {
     // ---- entity data ---------------------------------------------------
 
-    /// `NbtPredicate.getEntityTagToCompare`: the entity as saved.
+    /// `NbtPredicate.getEntityTagToCompare`: the entity as saved. An entity
+    /// in another level is read in the level that holds it.
     pub(in crate::game) fn entity_nbt(&mut self, t: Target) -> Option<Tag> {
+        self.in_target_level(t, |g| g.entity_nbt_in_level(t))
+            .flatten()
+    }
+    fn entity_nbt_in_level(&mut self, t: Target) -> Option<Tag> {
         let player_uuid = self.level.player_uuid;
         Some(match t {
             Target::Guest(_) => {
@@ -113,9 +118,11 @@ impl Game<'_> {
                 let o = self.others.iter().find(|o| o.id == id)?.clone();
                 self.other_to_nbt(&o, uuid)
             }
-            Target::Orb(i) => entity_nbt::orb_to_nbt(self.orbs.get(i)?, random_uuid()),
-            Target::Projectile(i) => {
-                let p = self.creatures.projectiles.get(i)?;
+            Target::Orb(id) => {
+                entity_nbt::orb_to_nbt(self.orbs.iter().find(|o| o.id == id)?, random_uuid())
+            }
+            Target::Projectile(id) => {
+                let p = self.creatures.projectiles.iter().find(|p| p.id == id)?;
                 let owner = if p.owner == Some(horizon_client::mobs::Who::Player) {
                     player_uuid
                 } else {
@@ -129,6 +136,16 @@ impl Game<'_> {
                 entity_nbt::arrow_to_nbt(p, random_uuid(), owner, in_block, None)
                     .or_else(|| entity_nbt::fireball_to_nbt(p, random_uuid(), owner, None))?
             }
+            Target::Crystal(id) => {
+                let c = self.crystals.iter().find(|c| c.id == id)?;
+                let (uuid, raw) = self.persist_anon("minecraft:end_crystal", c.position);
+                c.to_nbt(uuid.unwrap_or_else(random_uuid), raw)
+            }
+            Target::Dragon(id) => {
+                let d = self.dragon.as_ref().filter(|d| d.id == id)?;
+                let (uuid, raw) = self.persist_anon("minecraft:ender_dragon", d.position);
+                d.to_nbt(uuid.unwrap_or_else(random_uuid), raw)
+            }
         })
     }
     /// `Entity.load` of new data (`EntityDataAccessor.setData`): the entity is
@@ -397,6 +414,19 @@ impl Game<'_> {
     }
     pub(super) fn cmd_data(&mut self, id: &str, ctx: &Context) -> R<i32> {
         let target = self.data_ref(ctx, 0)?;
+        // An entity in another level is read and written in the level that
+        // holds it.
+        if let DataRef::Entity(t) = &target {
+            let t = *t;
+            let target = target.clone();
+            return match self.in_target_level(t, |g| g.cmd_data_in(id, ctx, target)) {
+                Some(r) => r,
+                None => Err(err("argument.entity.notfound.entity", &[])),
+            };
+        }
+        self.cmd_data_in(id, ctx, target)
+    }
+    fn cmd_data_in(&mut self, id: &str, ctx: &Context, target: DataRef) -> R<i32> {
         match id {
             "data.merge" => {
                 let Some(Arg::Str(nbt)) = ctx.get("nbt") else {
diff --git a/crates/horizon-client/src/game/commands/effects.rs b/crates/horizon-client/src/game/commands/effects.rs
index 65d6592f7..3a26f6c0d 100644
--- a/crates/horizon-client/src/game/commands/effects.rs
+++ b/crates/horizon-client/src/game/commands/effects.rs
@@ -1,11 +1,10 @@
 //! `/effect` (EffectCommands) and `/enchant` (EnchantCommand).
 use super::{Arg, Context, Game, R, Target, err, texts};
 use horizon_client::{
-    brewing,
+    brewing::{self, namespaced},
     effects::EffectInstance,
     text::{self, Style, Text},
 };
-use std::{collections::HashMap, sync::OnceLock};
 
 /// `CommandResponseTracker` over targets: elements with a non-zero result.
 #[derive(Default)]
@@ -21,24 +20,6 @@ impl Tracker {
         }
     }
 }
-/// Namespaced effect ids for mob effect storage.
-fn namespaced(id: &'static str) -> &'static str {
-    static IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
-    IDS.get_or_init(|| {
-        brewing::EFFECTS
-            .iter()
-            .map(|e| {
-                (
-                    e.id,
-                    &*Box::leak(format!("minecraft:{}", e.id).into_boxed_str()),
-                )
-            })
-            .collect()
-    })
-    .get(id)
-    .copied()
-    .unwrap_or(id)
-}
 fn effect_name(id: &str) -> Text {
     Text::translate(&format!("effect.minecraft.{id}"), &[])
 }
@@ -91,7 +72,12 @@ impl Game<'_> {
                 }
                 Target::Mob(id) => match self.mobs.iter_mut().find(|m| m.id == id) {
                     Some(m) => {
-                        m.add_effect(namespaced(effect.id), duration, amplifier);
+                        let name = namespaced(effect.id);
+                        m.add_effect(name, duration, amplifier);
+                        m.extra.hidden_effects.retain(|h| *h != name);
+                        if !particles {
+                            m.extra.hidden_effects.push(name);
+                        }
                         true
                     }
                     None => false,
@@ -154,6 +140,10 @@ impl Game<'_> {
                         m.extra
                             .effects
                             .retain(|x| e.is_some_and(|e| x.0 != namespaced(e.id)));
+                        let left = &m.extra.effects;
+                        m.extra
+                            .hidden_effects
+                            .retain(|h| left.iter().any(|x| x.0 == *h));
                         m.extra.effects.len() != before
                     }
                     None => false,
diff --git a/crates/horizon-client/src/game/commands/execute.rs b/crates/horizon-client/src/game/commands/execute.rs
index 3f7e4c2a0..12aedc59a 100644
--- a/crates/horizon-client/src/game/commands/execute.rs
+++ b/crates/horizon-client/src/game/commands/execute.rs
@@ -145,9 +145,42 @@ impl Game<'_> {
                 .iter()
                 .find(|m| m.id == id)
                 .map_or(0.0, |m| m.eye_y() - m.position.y),
-            _ => 0.0,
+            // ArmorStand.getDefaultDimensions: a marker's are empty, a small
+            // stand's are BABY_DIMENSIONS, whose eye height is 0.9875F.
+            Target::Stand(id) => match self.armor_stands.iter().find(|a| a.id == id) {
+                Some(a) if a.marker => 0.0,
+                Some(a) if a.small => f64::from(0.9875f32),
+                _ => self.type_eye_height(&self.target_type(t)),
+            },
+            // Entity.getEyeHeight: the type's dimensions.
+            _ => self.type_eye_height(&self.target_type(t)),
         }
     }
+    /// `EntityType.getDimensions().eyeHeight()` from `entity-types.json`,
+    /// read once: a float, widened as `Entity.getEyeY` does.
+    fn type_eye_height(&self, ty: &str) -> f64 {
+        static EYE_HEIGHTS: std::sync::OnceLock<std::collections::HashMap<String, f64>> =
+            std::sync::OnceLock::new();
+        EYE_HEIGHTS
+            .get_or_init(|| {
+                std::fs::read(self.options.resources.join("entity-types.json"))
+                    .ok()
+                    .and_then(|b| serde_json::from_slice::<serde_json::Value>(&b).ok())
+                    .and_then(|v| {
+                        v.as_object().map(|o| {
+                            o.iter()
+                                .filter_map(|(k, t)| {
+                                    Some((k.clone(), f64::from(t["eye_height"].as_f64()? as f32)))
+                                })
+                                .collect()
+                        })
+                    })
+                    .unwrap_or_default()
+            })
+            .get(ty)
+            .copied()
+            .unwrap_or(0.0)
+    }
     /// EntityAnchorArgument.Anchor.apply.
     pub(super) fn anchor_position(&self, s: &Source) -> [f64; 3] {
         match s.entity {
@@ -467,9 +500,10 @@ impl Game<'_> {
             "positioned" if c.has("as") => targets(self)?
                 .into_iter()
                 .filter_map(|t| {
+                    // withPosition keeps the anchor (only `positioned <pos>`
+                    // resets it to the feet).
                     Some(Source {
                         pos: self.target_position(t)?,
-                        eyes: false,
                         ..s
                     })
                 })
@@ -606,6 +640,73 @@ impl Game<'_> {
                     .collect(),
                 _ => Vec::new(),
             },
+            // Leashable.getLeashHolder: a fence knot is not an entity here.
+            Some("leasher") => match entity {
+                Target::Mob(id) => self
+                    .mobs
+                    .iter()
+                    .find(|m| m.id == id)
+                    .and_then(|m| m.extra.leash.map(|holder| (holder, m.extra.leash_player)))
+                    .and_then(|(holder, player)| match holder {
+                        // The player who tied it (the host's when unrecorded).
+                        horizon_client::mobs::leash::Holder::Player => {
+                            let uuid = player.or(self.level.player_uuid)?;
+                            self.target_by_uuid(horizon_client::lan::playerdata::ints_uuid(uuid))
+                        }
+                        horizon_client::mobs::leash::Holder::Mob(i) => Some(Target::Mob(i)),
+                        horizon_client::mobs::leash::Holder::Knot(_) => None,
+                    })
+                    .into_iter()
+                    .collect(),
+                _ => Vec::new(),
+            },
+            // TraceableEntity.getOwner: who shot a projectile, who threw an
+            // item, who summoned a vex.
+            Some("origin") => match entity {
+                Target::Projectile(id) => self
+                    .creatures
+                    .projectiles
+                    .iter()
+                    .find(|p| p.id == id)
+                    .and_then(|p| match (p.owner?, p.guest) {
+                        // A guest's shot: `Who::Player` is them.
+                        (horizon_client::mobs::Who::Player, Some(conn))
+                            if self.lan_acting == Some(conn) =>
+                        {
+                            Some(Target::Player)
+                        }
+                        (horizon_client::mobs::Who::Player, Some(conn)) => {
+                            Some(Target::Guest(conn))
+                        }
+                        (horizon_client::mobs::Who::Player, None) => Some(Target::Player),
+                        (horizon_client::mobs::Who::Mob(id), _) => Some(Target::Mob(id)),
+                    })
+                    .into_iter()
+                    .collect(),
+                Target::Item(id) => self
+                    .dropped
+                    .iter()
+                    .find(|d| d.id == id)
+                    .and_then(|d| d.thrower)
+                    .and_then(|words| {
+                        let uuid = words
+                            .iter()
+                            .fold(0u128, |all, w| all << 32 | u128::from(*w as u32));
+                        self.target_by_uuid(uuid)
+                    })
+                    .into_iter()
+                    .collect(),
+                Target::Mob(id) => self
+                    .mobs
+                    .iter()
+                    .find(|m| m.id == id && m.kind.id == "minecraft:vex")
+                    .map(|m| m.extra.counter2 as u32)
+                    .filter(|owner| *owner != 0)
+                    .map(Target::Mob)
+                    .into_iter()
+                    .collect(),
+                _ => Vec::new(),
+            },
             Some("vehicle") => self.ride_vehicle(entity).into_iter().collect(),
             Some("controller") | Some("passengers") => match entity {
                 Target::Mob(id) if self.mobs.iter().any(|m| m.id == id && m.rider.is_some()) => {
@@ -807,10 +908,12 @@ impl Game<'_> {
                 .coords(c, "pos")
                 .map(|co| co.block(self.source_position(), self.source_rotation()));
             let dimension = self.command_source.map_or(self.dim, |s| s.dimension);
-            return Ok(flag(
-                dimension == self.dim
-                    && p.is_some_and(|p| self.world.chunks.contains_key(&(p[0] >> 4, p[2] >> 4))),
-            ));
+            // ExecuteCommand.isChunkLoaded: ENTITY_TICKING, which is past lit.
+            let loaded = |p: [i32; 3]| {
+                let key = (p[0] >> 4, p[2] >> 4);
+                self.world.chunks.contains_key(&key) && self.streaming.is_lit(key.0, key.1)
+            };
+            return Ok(flag(dimension == self.dim && p.is_some_and(loaded)));
         }
         if c.has("dimension") {
             let dimension = self.command_source.map_or(self.dim, |s| s.dimension);
diff --git a/crates/horizon-client/src/game/commands/pregen.rs b/crates/horizon-client/src/game/commands/pregen.rs
index d497e2734..eb3c37688 100644
--- a/crates/horizon-client/src/game/commands/pregen.rs
+++ b/crates/horizon-client/src/game/commands/pregen.rs
@@ -244,7 +244,11 @@ impl Game<'_> {
     /// hand them the next jobs as soon as each one is done, rather than once
     /// a tick.
     pub(in crate::game) fn pump_pregen(&mut self, until: Instant) {
-        while self.pregen_runs_here() {
+        // Force-loaded chunks too: decorating in vanilla's order, a chunk
+        // waits for its neighbours far more often than once a tick allows.
+        while self.pregen_runs_here()
+            || (!self.streaming.forced.is_empty() && self.streaming.busy())
+        {
             let now = Instant::now();
             if now >= until {
                 break;
diff --git a/crates/horizon-client/src/game/commands/terrain_cmds.rs b/crates/horizon-client/src/game/commands/terrain_cmds.rs
index d4b1c125c..824ca4d60 100644
--- a/crates/horizon-client/src/game/commands/terrain_cmds.rs
+++ b/crates/horizon-client/src/game/commands/terrain_cmds.rs
@@ -120,6 +120,9 @@ impl Game<'_> {
                         tracker.track(&holder(chunk_text(x, z)), i32::from(changed));
                     }
                 }
+                if add {
+                    self.streaming.rank_forced(cx0, cz0, cx1, cz1);
+                }
                 let (lo, hi) = (chunk_text(cx0, cz0), chunk_text(cx1, cz1));
                 let verb = if add { "added" } else { "removed" };
                 let (message, total) = tracker.message(
diff --git a/crates/horizon-client/src/game/commands/text_commands.rs b/crates/horizon-client/src/game/commands/text_commands.rs
index dead07d71..020157f83 100644
--- a/crates/horizon-client/src/game/commands/text_commands.rs
+++ b/crates/horizon-client/src/game/commands/text_commands.rs
@@ -14,10 +14,11 @@ impl Game<'_> {
             serde_json::from_str(json).map_err(|e| err("argument.component.invalid", &[&e]))?;
         // NbtContents.resolve: the path's values in the entity, block or
         // storage data, rich-styled (or plain, or interpreted), ", "-joined.
+        // ScoreContents.resolve: the holder's score in the objective.
         let nbt_values = std::cell::RefCell::new(Vec::new());
         {
             let mut collect = |o: &serde_json::Map<String, serde_json::Value>| {
-                if o.contains_key("nbt") {
+                if o.contains_key("nbt") || o.contains_key("score") {
                     nbt_values.borrow_mut().push(o.clone());
                 }
             };
@@ -40,7 +41,11 @@ impl Game<'_> {
         }
         let mut resolved: Vec<(serde_json::Map<String, serde_json::Value>, Text)> = Vec::new();
         for o in nbt_values.into_inner() {
-            let t = self.resolve_nbt_component(&o);
+            let t = if o.contains_key("score") {
+                self.resolve_score_component(&o)?
+            } else {
+                self.resolve_nbt_component(&o)
+            };
             resolved.push((o, t));
         }
         let mut resolve = |raw: &str| -> Text {
@@ -73,6 +78,54 @@ impl Game<'_> {
             },
         ))
     }
+    /// The text of a `score` component (ScoreContents.resolve): the named
+    /// holder's score, `*` being the player the command runs for.
+    fn resolve_score_component(
+        &mut self,
+        o: &serde_json::Map<String, serde_json::Value>,
+    ) -> R<Text> {
+        let score = o.get("score");
+        let field = |k: &str| score.and_then(|s| s.get(k)).and_then(|v| v.as_str());
+        let (name, objective) = (
+            field("name").unwrap_or(""),
+            field("objective").unwrap_or(""),
+        );
+        // findTargetName: a selector that matches one entity is that entity,
+        // one that matches none is just the name.
+        let mut reader = horizon_client::command::Reader::new(name);
+        let ty = horizon_client::command::args::ArgType::Entity {
+            single: false,
+            players: false,
+        };
+        let mut holder = name.to_owned();
+        if let Ok(Arg::Entity(sel)) = ty.parse(&mut reader, &self.ui.registries)
+            && !reader.can_read()
+        {
+            let found = self.select(&sel);
+            if found.len() > 1 {
+                return Err(err("argument.entity.toomany", &[]));
+            }
+            if let Some(t) = found.first().and_then(|t| self.holder_name(*t)) {
+                holder = t;
+            }
+        }
+        if holder == "*" {
+            holder = self.acting_player_name().to_owned();
+        }
+        let board = &self.score.board;
+        let (Some(objective), Some(score)) =
+            (board.objective(objective), board.score(&holder, objective))
+        else {
+            return Ok(Text::empty());
+        };
+        // numberFormatOrDefault(StyledFormat.NO_STYLE).
+        let format = (score.number_format.clone())
+            .or_else(|| objective.number_format.clone())
+            .unwrap_or(horizon_client::scoreboard::NumberFormat::Styled(
+                serde_json::json!({}),
+            ));
+        Ok(format.format(score.value))
+    }
     /// The text of an `nbt` component.
     fn resolve_nbt_component(&mut self, o: &serde_json::Map<String, serde_json::Value>) -> Text {
         use horizon_world::nbt::Tag;
@@ -136,28 +189,40 @@ impl Game<'_> {
         }
         out
     }
-    fn player_targets(&mut self, ctx: &Context) -> R<usize> {
-        // Only the local player can receive messages and titles.
+    /// The players the command reaches: the window's own and the LAN guests.
+    fn player_targets(&mut self, ctx: &Context) -> R<Vec<Target>> {
         let targets = self.entities(ctx, "targets", true)?;
-        Ok(targets.iter().filter(|t| **t == Target::Player).count())
+        Ok(targets
+            .into_iter()
+            .filter(|t| matches!(t, Target::Player | Target::Guest(_)))
+            .collect())
     }
     pub(super) fn cmd_tellraw(&mut self, ctx: &Context) -> R<i32> {
-        let n = self.player_targets(ctx)?;
+        let players = self.player_targets(ctx)?;
         let message = self.component_arg(ctx, "message")?;
-        if n > 0 {
-            self.system_message(message);
+        // Each player's chat (a guest's through the connection).
+        for &t in &players {
+            self.for_player(t, |g| g.system_message(message.clone()));
         }
-        Ok(n as i32)
+        Ok(players.len() as i32)
     }
     pub(super) fn cmd_title(&mut self, ctx: &Context) -> R<i32> {
-        let n = self.player_targets(ctx)?;
-        let name = self.target_name(Target::Player);
+        let players = self.player_targets(ctx)?;
+        let n = players.len();
+        let name = players
+            .first()
+            .map_or_else(Text::empty, |t| self.target_name(*t));
         let single = n == 1;
         let key = if ctx.has("clear") {
-            self.titles_or_packet(Titles::clear, C::ClearTitles(play::Bool1 { value: false }));
+            self.titles_or_packet(
+                &players,
+                Titles::clear,
+                C::ClearTitles(play::Bool1 { value: false }),
+            );
             "cleared"
         } else if ctx.has("reset") {
             self.titles_or_packet(
+                &players,
                 |t| {
                     t.clear();
                     t.reset_times();
@@ -172,6 +237,7 @@ impl Game<'_> {
             };
             let (fade_in, stay, fade_out) = (get("fadeIn"), get("stay"), get("fadeOut"));
             self.titles_or_packet(
+                &players,
                 |t| t.set_times(fade_in, stay, fade_out),
                 C::SetTitlesAnimation(play::TitlesAnimation {
                     fade_in,
@@ -186,13 +252,17 @@ impl Game<'_> {
                 text: component_nbt(&text.component()),
             };
             if ctx.has("subtitle") {
-                self.titles_or_packet(|t| t.set_subtitle(text), C::SetSubtitleText(sent));
+                self.titles_or_packet(&players, |t| t.set_subtitle(text), C::SetSubtitleText(sent));
                 "show.subtitle"
             } else if ctx.has("actionbar") {
-                self.titles_or_packet(|t| t.set_overlay(text, false), C::SetActionBarText(sent));
+                self.titles_or_packet(
+                    &players,
+                    |t| t.set_overlay(text, false),
+                    C::SetActionBarText(sent),
+                );
                 "show.actionbar"
             } else {
-                self.titles_or_packet(|t| t.set_title(text), C::SetTitleText(sent));
+                self.titles_or_packet(&players, |t| t.set_title(text), C::SetTitleText(sent));
                 "show.title"
             }
         };
@@ -207,13 +277,27 @@ impl Game<'_> {
         self.feedback(message);
         Ok(n as i32)
     }
-    /// The player the title is for: the guest acting now is sent the packet
-    /// (TitleCommand's `connection.send`), the window's own player shows it.
-    fn titles_or_packet(&mut self, local: impl FnOnce(&mut Titles), packet: C) {
-        if self.lan_acting.is_some() {
-            self.guest_packets.push(packet);
-        } else {
-            local(&mut self.titles);
+    /// TitleCommand's `connection.send` for each player: a guest is sent the
+    /// packet, the window's own player shows it.
+    fn titles_or_packet(&mut self, players: &[Target], local: impl FnOnce(&mut Titles), packet: C) {
+        let mut local = Some(local);
+        for &t in players {
+            match t {
+                Target::Player if self.lan_acting.is_some() => {
+                    self.guest_packets.push(packet.clone());
+                }
+                Target::Player => {
+                    if let Some(local) = local.take() {
+                        local(&mut self.titles);
+                    }
+                }
+                Target::Guest(conn) => {
+                    if let Some(host) = self.lan.as_ref() {
+                        host.hub.send_to(conn, &packet);
+                    }
+                }
+                _ => {}
+            }
         }
     }
 }
diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs
index 687eb3f88..39587fa00 100644
--- a/crates/horizon-client/src/game/commands/world_cmds.rs
+++ b/crates/horizon-client/src/game/commands/world_cmds.rs
@@ -115,9 +115,11 @@ impl Game<'_> {
             "in_fire" | "campfire" | "hot_floor" => DamageKind::InFire,
             "lava" => DamageKind::Lava,
             "drown" => DamageKind::Drown,
+            "dry_out" => DamageKind::DryOut,
             "magic" | "indirect_magic" | "dragon_breath" => DamageKind::Magic,
             "sting" => DamageKind::Sting,
             "cactus" | "sweet_berry_bush" => DamageKind::Cactus,
+            "freeze" => DamageKind::Freeze,
             "in_wall" => DamageKind::InWall,
             "thorns" => DamageKind::Thorns,
             _ => DamageKind::Generic,
@@ -140,27 +142,37 @@ impl Game<'_> {
             Some(Arg::Entity(_)) => self.entities(ctx, "entity", false)?.first().copied(),
             _ => None,
         };
+        let cause = match ctx.get("cause") {
+            Some(Arg::Entity(_)) => self.entities(ctx, "cause", false)?.first().copied(),
+            _ => None,
+        };
         let from = match ctx.get("location") {
             Some(Arg::Coords(_)) => self.position_arg(ctx, "location"),
             _ => by.and_then(|t| self.target_position(t)),
         };
         let hurt = match target {
+            // The causing mob is the one the hit is credited to and thorns
+            // answer; the source position gives the knockback its direction.
             Target::Player => {
-                if self.creative || self.spectator() {
+                // `DamageSource(type, cause, by)`: the death message names the
+                // causing entity, else the direct one. A mob is noted by
+                // `hurt_player_from`, a player here.
+                if let Some(t @ (Target::Player | Target::Guest(_))) = cause.or(by) {
+                    let name = self.target_name(t);
+                    self.note_direct_entity(&ty, name);
+                }
+                if self.spectator() {
                     false
-                } else if let Some(player) = self.player.as_mut() {
-                    match self.motion.health.damage.id(&ty) {
-                        Some(id) => player
-                            .hurt(&self.motion.health, self.world.health_rules, id, amount)
-                            .unwrap_or(false),
-                        None => false,
-                    }
                 } else {
-                    false
+                    let attacker = match cause.or(by) {
+                        Some(Target::Mob(i)) => Some(Some(i)),
+                        _ => Some(None),
+                    };
+                    self.hurt_player_from(amount, from, &ty, attacker)
                 }
             }
             Target::Mob(id) => {
-                let attacker = by.and_then(|t| match t {
+                let attacker = cause.or(by).and_then(|t| match t {
                     Target::Player => Some(Who::Player),
                     Target::Mob(i) => Some(Who::Mob(i)),
                     _ => None,
@@ -301,9 +313,18 @@ impl Game<'_> {
             float("minVolume", 0.0),
         );
         let range = if volume > 1.0 { 16.0 * volume } else { 16.0 };
+        // PlaySoundCommand: one seed for every player.
+        let seed = self.world.random.next_long();
+        let here = self.dim.id();
         let mut tracker = Tracker::default();
         for t in targets {
-            if t != Target::Player {
+            if !matches!(t, Target::Player | Target::Guest(_)) {
+                continue;
+            }
+            // Only players in the source's level hear it.
+            if let Target::Guest(conn) = t
+                && self.command_guest(conn).is_none_or(|g| g.dimension != here)
+            {
                 continue;
             }
             let Some(p) = self.target_position(t) else {
@@ -327,8 +348,26 @@ impl Game<'_> {
             } else {
                 (pos, volume)
             };
-            self.audio.play_on(source, &sound, Some(at), v, pitch);
-            tracker.mark(&holder(Text::literal(self.acting_player_name())));
+            // The connection is sent the sound; the window's own player
+            // plays it.
+            let guest = match t {
+                Target::Guest(conn) => Some(conn),
+                _ => self.lan_acting,
+            };
+            match guest.and_then(|conn| Some((conn, self.lan.as_ref()?))) {
+                Some((conn, host)) => {
+                    let packet = host
+                        .hub
+                        .sound_packet(&sound, at, v, pitch, source as i32, seed);
+                    if t == Target::Player {
+                        self.guest_packets.push(packet);
+                    } else {
+                        host.hub.send_to(conn, &packet);
+                    }
+                }
+                None => self.audio.play_on(source, &sound, Some(at), v, pitch),
+            }
+            tracker.mark(&holder(self.target_name(t)));
         }
         let name = Text::literal(sound.clone());
         let (message, total) = tracker.message(
@@ -605,8 +644,10 @@ impl Game<'_> {
         let reached = reached.len() as i32;
         if !local {
         } else if count <= 0 {
-            // No count: one particle with the delta as velocity.
-            self.particles.create(&options, pos, delta);
+            // handleParticleEvent, count 0: one particle, the speed times
+            // the delta as velocity (both sent as floats, multiplied as floats).
+            self.particles
+                .create(&options, pos, delta.map(|d| f64::from(speed * d as f32)));
         } else {
             for _ in 0..count {
                 let r = self.particles.random();
diff --git a/crates/horizon-client/src/game/composter.rs b/crates/horizon-client/src/game/composter.rs
index 3f57229ad..4013155ad 100644
--- a/crates/horizon-client/src/game/composter.rs
+++ b/crates/horizon-client/src/game/composter.rs
@@ -5,6 +5,7 @@
 use super::{Game, commands::compute::ComputeContext};
 use horizon_client::{
     items::ItemStack,
+    mobs::villager,
     particles::{ParticleOptions, ParticleType},
 };
 use horizon_core::{position::BlockPos, random::RandomSource};
@@ -86,6 +87,82 @@ impl Game<'_> {
         self.composter_add(pos, &layers);
         (stack.count > 0).then_some(stack)
     }
+    /// `WorkAtComposter.compostItems` for the villager at `mob`: a full
+    /// composter is emptied, then up to 20 wheat or beetroot seeds go in
+    /// (keeping 10 of each kind) until the composter reaches level 7. Level
+    /// event 1500 plays once, at the end.
+    pub(super) fn villager_compost_items(&mut self, mob: usize, pos: [i32; 3]) {
+        let at = BlockPos::new(pos[0], pos[1], pos[2]);
+        let Some(mut before) = self.composter_level(pos) else {
+            return;
+        };
+        if before == 8 {
+            self.with_level(|b, level, ticks| b.composter_extract(level, ticks, at));
+            let _ = self.process_level_events();
+            before = 0;
+        }
+        let mut remaining = 20;
+        let mut amounts: Vec<(std::sync::Arc<str>, i32)> = Vec::new();
+        let slots = villager::ext(&self.mobs[mob]).map_or(0, |e| e.inventory.len());
+        'slots: for slot in (0..slots).rev() {
+            if remaining <= 0 {
+                break;
+            }
+            let stack = villager::ext_mut(&mut self.mobs[mob]).inventory[slot].clone();
+            if !matches!(
+                &*stack.item,
+                "minecraft:wheat_seeds" | "minecraft:beetroot_seeds"
+            ) {
+                continue;
+            }
+            let known = amounts.iter().position(|(item, _)| *item == stack.item);
+            let total = known.map_or(0, |k| amounts[k].1) + stack.count as i32;
+            match known {
+                Some(k) => amounts[k].1 = total,
+                None => amounts.push((stack.item.clone(), total)),
+            }
+            let uses = (total - 10).min(remaining).min(stack.count as i32);
+            if uses <= 0 {
+                continue;
+            }
+            remaining -= uses;
+            for _ in 0..uses {
+                self.villager_insert_item(mob, slot, &stack, pos);
+                if self.composter_level(pos) == Some(7) {
+                    break 'slots;
+                }
+            }
+        }
+        let after = self.composter_level(pos).unwrap_or(before);
+        self.with_level(|b, level, ticks| {
+            b.composter_fill_effects(level, ticks, at, after != before)
+        });
+        let _ = self.process_level_events();
+    }
+    /// `ComposterBlock.insertItem` with a villager's stack: below level 7 a
+    /// compostable item is used up and may add a layer.
+    fn villager_insert_item(&mut self, mob: usize, slot: usize, stack: &ItemStack, pos: [i32; 3]) {
+        if self.composter_level(pos).is_none_or(|level| level >= 7) {
+            return;
+        }
+        let Some(layers) = self.compostable(stack) else {
+            return;
+        };
+        let context = ComputeContext {
+            block: Some(pos),
+            target: None,
+        };
+        let layers = self.provider_int(&layers, &context, 0).unwrap_or(0);
+        let at = BlockPos::new(pos[0], pos[1], pos[2]);
+        self.with_level(|b, level, ticks| b.composter_layer(level, ticks, at, layers));
+        self.world.modified.insert((pos[0] >> 4, pos[2] >> 4));
+        let _ = self.process_level_events();
+        let inventory = &mut villager::ext_mut(&mut self.mobs[mob]).inventory;
+        inventory[slot].count -= 1;
+        if inventory[slot].count == 0 {
+            inventory.remove(slot);
+        }
+    }
     /// `ComposterBlock.handleFill` (level event 1500) on the client: the
     /// fill sound and ten composter particles above the compost.
     pub(super) fn composter_fill_event(&mut self, pos: BlockPos, success: bool) {
diff --git a/crates/horizon-client/src/game/consume.rs b/crates/horizon-client/src/game/consume.rs
index 93d919911..e5fae08ca 100644
--- a/crates/horizon-client/src/game/consume.rs
+++ b/crates/horizon-client/src/game/consume.rs
@@ -19,7 +19,17 @@ use std::convert::Infallible;
 
 type ItemConsumable = Consumable<String, ConsumeEffect>;
 
+/// `EntityEvent.USE_ITEM_COMPLETE`: the server finished the player's use.
+pub(super) const USE_ITEM_COMPLETE_EVENT: i8 = 9;
+
 impl Game<'_> {
+    /// `ServerPlayer.completeUsingItem`: the player's own client is told
+    /// first, and completes the use itself (eating the food there too).
+    pub(super) fn send_use_item_complete(&mut self) {
+        if self.lan_acting.is_some() {
+            self.guest_entity_events.push(USE_ITEM_COMPLETE_EVENT);
+        }
+    }
     /// `Consumable.emitParticlesAndSounds(user.getRandom(), user, stack, count)`.
     pub(super) fn emit_consume(
         &mut self,
@@ -57,6 +67,17 @@ impl Game<'_> {
             self.audio
                 .play("minecraft:entity.player.burp", self.feet(), 0.5, pitch);
         }
+        // SuspiciousStewEffects.onConsume, a ConsumableListener: each entry is
+        // added as a `MobEffectInstance(effect, duration)` (amplifier 0).
+        if let Some(data) = stack.extra.as_deref() {
+            for (id, duration) in &data.stew_effects {
+                if let Some(def) = horizon_client::brewing::effect(id) {
+                    self.add_player_effect(horizon_client::effects::EffectInstance::new(
+                        def.id, *duration, 0,
+                    ));
+                }
+            }
+        }
         for effect in &consumable.effects {
             self.apply_consume_effect(effect);
         }
diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs
index 3202b23f4..0fe5d89ce 100644
--- a/crates/horizon-client/src/game/control.rs
+++ b/crates/horizon-client/src/game/control.rs
@@ -628,6 +628,9 @@ impl Game<'_> {
                     // The port, or the game rules' search and number boxes.
                     Screen::WorldOptions if text == "\\b" => self.world_options_text(None),
                     Screen::WorldOptions => self.world_options_text(Some(text)),
+                    Screen::Inventory if self.mod_browser_typing() => {
+                        self.mod_browser_text((text != "\\b").then_some(text), text == "\\b")
+                    }
                     Screen::Inventory if self.recipe_search_focused() => {
                         self.recipe_text(Some(text), false)
                     }
@@ -875,6 +878,9 @@ impl Game<'_> {
             Screen::Advancements => "advancements",
             Screen::WorldOptions => "world-options",
             Screen::Friends => "friends",
+            Screen::ServerLinks => "server-links",
+            Screen::ConfirmLink => "confirm-link",
+            Screen::DialogWarning => "dialog-warning",
             Screen::CommandBlock => "command-block",
             Screen::Win => "win",
             Screen::Mod => "mod",
@@ -1080,6 +1086,9 @@ impl Game<'_> {
             "flashes": self.lightning_seen[1], "flash": self.flash});
         // Primed TNT, falling blocks, projectiles, tridents and end crystals.
         status["projectiles"] = json!(self.projectiles_status());
+        let mut fangs_vertices = Vec::new();
+        self.fangs_geometry(glam::DVec3::ZERO, 0.5, &mut fangs_vertices);
+        status["fangs_vertices"] = json!(fangs_vertices.len());
         status["maps"] = json!(self.maps_status());
         // The particles made so far, by type.
         status["particles"] = json!(self.particles.made());
diff --git a/crates/horizon-client/src/game/copper_golems.rs b/crates/horizon-client/src/game/copper_golems.rs
index 2f98e1c7e..db4e03b0b 100644
--- a/crates/horizon-client/src/game/copper_golems.rs
+++ b/crates/horizon-client/src/game/copper_golems.rs
@@ -44,13 +44,13 @@ impl Game<'_> {
         slot: usize,
         stack: Option<ItemStack>,
     ) {
-        if let Some(e) = self
-            .world
-            .block_entities
-            .get_mut(&(chest[0], chest[1], chest[2]))
+        let key = (chest[0], chest[1], chest[2]);
+        if let Some(e) = self.world.block_entities.get_mut(&key)
             && let Some(s) = e.slots_mut().get_mut(slot)
         {
             *s = stack;
+            // TransportItemsBetweenContainers calls Container.setChanged.
+            self.container_changed(key);
         }
     }
     /// `ContainerOpenersCounter.recheckOpeners` every five ticks: the golems
diff --git a/crates/horizon-client/src/game/creaking.rs b/crates/horizon-client/src/game/creaking.rs
index c75325c2f..19b3442c2 100644
--- a/crates/horizon-client/src/game/creaking.rs
+++ b/crates/horizon-client/src/game/creaking.rs
@@ -218,8 +218,9 @@ impl Game<'_> {
         );
     }
     /// `CreakingHeartBlock.playerWillDestroy`: the heart's creaking twitches to
-    /// death and a natural heart drops experience.
-    pub(super) fn creaking_heart_broken(&mut self, pos: [i32; 3]) {
+    /// death and a natural heart drops experience. `onExplosionHit` does the
+    /// same for the creaking (`by_player` false), without the experience.
+    pub(super) fn creaking_heart_broken(&mut self, pos: [i32; 3], by_player: bool) {
         let key = (pos[0], pos[1], pos[2]);
         if !matches!(
             self.world.block_entities.get(&key),
@@ -242,7 +243,7 @@ impl Game<'_> {
             .state(state)
             .and_then(|s| s.properties.get("natural").cloned())
             .is_some_and(|v| v == "true");
-        if natural && !self.creative && !self.spectator() {
+        if by_player && natural && !self.creative && !self.spectator() {
             let xp = 20 + self.world.random.next_int_bound(5).unwrap_or(0) as u32;
             self.spawn_orbs(
                 [
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 2b65a3289..34319d462 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -18,6 +18,7 @@ use horizon_client::{
         spawning::{self, BiomeFacts},
     },
     projectiles::{Hit, Projectile, ProjectileKind, ProjectileWorld},
+    text::Text,
 };
 use horizon_core::{
     geometry::{Aabb, Vec3, traverse_blocks},
@@ -45,10 +46,22 @@ pub(super) struct Creatures {
     pub projectiles: Vec<Projectile>,
     /// Wind bursts from a guest's turn, waiting for it to end (game/wind.rs).
     pub wind_bursts: Vec<super::wind::Burst>,
+    /// Explosion packets from a guest's turn, waiting for it to end
+    /// (centre, small, radius, blocks hit; game/lan_particles.rs).
+    pub lan_explosions: Vec<([f64; 3], bool, f32, usize)>,
     /// Ticks left of the elder guardian's apparition (MobAppearanceParticle).
     pub elder_apparition: i32,
     /// The wandering trader spawner's clock.
     pub trader: super::wandering_trader::Spawner,
+    /// Particles from a guest's turn, waiting for it to end
+    /// (`lan_send_particles`: options, centre, spread, speed, count).
+    pub lan_particles: Vec<(
+        horizon_client::particles::ParticleOptions,
+        [f64; 3],
+        [f64; 3],
+        f64,
+        u32,
+    )>,
 }
 pub(super) struct ProjWorld<'a, 'w> {
     pub w: &'a MobWorld<'w>,
@@ -145,6 +158,8 @@ fn flame_geometry(
                 layer: 0,
                 color: 0xFFFF_FFFF,
                 light: packed,
+
+                glint_uv: [0.0, 0.0],
             });
         }
         h -= 0.45;
@@ -186,6 +201,7 @@ impl Game<'_> {
             off_hand: None,
             head: self.armor[0].as_ref().map(|s| s.item.clone()),
             armor_cover: self.armor.iter().filter(|a| a.is_some()).count() as f32 / 4.0,
+            invisible: self.potions.effects.get("invisibility").is_some(),
             spectator: self.spectator(),
             gold_armor: self.wearing_gold(),
             hurt_by: self.player_hurt_by(),
@@ -193,9 +209,11 @@ impl Game<'_> {
             velocity: p.velocity,
             yaw: self.yaw,
             hero: self.potions.effects.get("hero_of_the_village").is_some(),
+            effects: self.potions.effects.list.iter().map(|e| e.id).collect(),
             uuid: self.level.player_uuid.unwrap_or_default(),
             allies: std::sync::Arc::new(self.player_allies()),
             remote: false,
+            passenger: self.riding.is_some(),
         })
     }
     /// Biome facts at a position for finalizeSpawn and variant rules.
@@ -400,6 +418,7 @@ impl Game<'_> {
             world: &self.world,
             registry: self.pack.assets.registry,
             facts: self.res.facts(),
+            fluid_tables: &self.motion.fluids,
             movement: &self.motion.blocks,
             collision: self.collision,
             data: self.res.mob_data(),
@@ -417,11 +436,13 @@ impl Game<'_> {
             block_tags: &self.res.items().block_tags,
             biomes: self.res.biomes(),
             mob_griefing: self.ui.rules.bool("mob_griefing"),
+            mob_drops: self.ui.rules.bool("mob_drops"),
             end: self.dim == Dim::End,
             world_seed: self.level.seed,
             sea_level: if self.dim == Dim::Nether { 32 } else { 63 },
             teams: std::sync::Arc::new(self.mob_teams()),
             items: Some(self.res.items()),
+            lid_openers: &self.lid_openers,
             difficulty: self.local_difficulty(
                 self.player
                     .as_ref()
@@ -429,6 +450,12 @@ impl Game<'_> {
             ),
         }
     }
+    /// What the generator finalizes this level's structure mobs with.
+    pub(super) fn share_spawn_conditions(&self) {
+        if let Some(terrain) = self.end.locator() {
+            terrain.set_spawn_conditions(self.difficulty_id() as u8, self.world.day_time);
+        }
+    }
     /// `ServerLevel.getCurrentDifficultyAt`.
     pub(super) fn local_difficulty(&self, at: [f64; 3]) -> spawning::LocalDifficulty {
         use horizon_world::food::Difficulty;
@@ -497,11 +524,14 @@ impl Game<'_> {
             self.died.insert(m.id);
             self.mob_died(&m);
         }
+        // Their victims have been looted: no charged creeper is waiting any more.
+        self.combat.charged_exploders.clear();
         let uuid = self.level.player_uuid;
         let mut snapshot: Vec<Seen> = self.mobs.iter().map(|m| seen(m, uuid)).collect();
         let mut events = Vec::new();
         let mut mobs = std::mem::take(&mut self.mobs);
         let mut dead = Vec::new();
+        let mut corpses = Vec::new();
         let mut died = std::mem::take(&mut self.died);
         let ticking = self.entity_ticking_area();
         // With guests on, each mob sees its nearest player (game/lan_mobs.rs).
@@ -523,6 +553,8 @@ impl Game<'_> {
             _ => Vec::new(),
         };
         let mut guest_events = Vec::new();
+        // The mobs whose bodies go this tick: (id, feet, width, height).
+        let mut gone = Vec::new();
         let level_random;
         {
             // The level random, lent to the mobs (brain behaviours draw from
@@ -594,7 +626,17 @@ impl Game<'_> {
                 horizon_client::mobs::apply_mob_pushes(m, &mut pushes);
                 let from = events.len();
                 let kept = m.tick(&w, &mut scratch, &mut events);
+                // A killed mob's body is removed: its effects that act on
+                // death run (`LivingEntity.remove` with KILLED).
+                if !kept && !m.alive() && !m.removed && !m.extra.effects.is_empty() {
+                    corpses.push(m.clone());
+                }
                 horizon_client::mobs::take_mob_pushes(&mut events, from, &mut pushes);
+                // LivingEntity.tickDeath: after twenty ticks the body is removed.
+                if !kept && !m.removed && !m.alive() && m.death_time >= 20 {
+                    let (width, height) = (f64::from(m.width()), f64::from(m.height()));
+                    gone.push((m.id, m.position, width, height));
+                }
                 if let Some(conn) = seen_guest {
                     // ShulkerBullet.finalTarget is the guest's entity: the
                     // bullet homes on it while the projectiles tick, where
@@ -653,15 +695,32 @@ impl Game<'_> {
         }
         self.mobs.append(&mut mobs);
         self.died = died;
+        // ... and entity event 60 goes out as it is: the poof.
+        for (id, at, width, height) in gone {
+            let at = [at.x, at.y, at.z];
+            self.lan_entity_event(id as i32, 60, at);
+            self.death_poof(at, width, height);
+        }
         self.sync_riders();
         self.tick_skeleton_traps();
         self.tick_apparition();
+        self.guardian_bubbles();
         self.villager_reputation_tick();
         self.merchant_tick();
         self.villager_pickups();
         for m in dead {
             self.mob_died(&m);
         }
+        for mut m in corpses {
+            let names: Vec<&'static str> = m
+                .extra
+                .effects
+                .iter()
+                .map(|e| e.0.trim_start_matches("minecraft:"))
+                .collect();
+            let bounds = m.bounds();
+            self.effects_on_death(&names, bounds, false, Some(m.id), Some(&mut m.random));
+        }
         self.handle_mob_events(events)?;
         self.lan_guest_mob_events(guest_events);
         self.tick_projectiles()?;
@@ -679,6 +738,22 @@ impl Game<'_> {
         self.handle_mob_events(queued)?;
         Ok(())
     }
+    /// `LivingEntity.makePoofParticles` (entity event 60) about a mob's box.
+    pub(super) fn death_poof(&mut self, at: [f64; 3], width: f64, height: f64) {
+        let options = horizon_client::particles::ParticleOptions::simple(
+            horizon_client::particles::ParticleType::Poof,
+        );
+        for _ in 0..20 {
+            let r = self.particles.level_random();
+            let xa = r.next_gaussian() * 0.02;
+            let ya = r.next_gaussian() * 0.02;
+            let za = r.next_gaussian() * 0.02;
+            let x = at[0] + width * (2.0 * r.next_double() - 1.0) - xa * 10.0;
+            let y = at[1] + height * r.next_double() - ya * 10.0;
+            let z = at[2] + width * (2.0 * r.next_double() - 1.0) - za * 10.0;
+            self.particles.add(&options, [x, y, z], [xa, ya, za]);
+        }
+    }
     /// LivingEntity.die / dropAllDeathLoot.
     fn mob_died(&mut self, m: &Mob) {
         let killer = self.last_hurt_by_player.remove(&m.id);
@@ -718,6 +793,7 @@ impl Game<'_> {
         self.villager_murdered(m, by_player);
         let pos = [m.position.x, m.position.y + 0.5, m.position.z];
         self.drop_death_loot(&mut dying, by_player, consumed, pos);
+        self.create_wither_rose(m);
         if m.species() == Species::CopperGolem {
             // CopperGolem.dropEquipment: the preserved equipment too.
             self.golem_drop_equipment(&mut dying);
@@ -779,7 +855,17 @@ impl Game<'_> {
                     .mobs
                     .iter()
                     .find(|o| o.id == id)
-                    .map(|o| drops::loot_entity(o, None)),
+                    .map(|o| drops::loot_entity(o, None))
+                    // A charged creeper's blast kills after the creeper left the list.
+                    .or_else(|| {
+                        self.combat
+                            .charged_exploders
+                            .contains(&id)
+                            .then(|| LootEntity {
+                                powered: true,
+                                ..LootEntity::new("minecraft:creeper")
+                            })
+                    }),
                 None => None,
             };
             let direct = match d.kind {
@@ -815,12 +901,12 @@ impl Game<'_> {
             world_seed: self.level.seed,
         };
         let (items, skulls) = drops::die(m, &death, &mut self.rand_sequences);
-        if skulls
-            && let Some(Who::Mob(id)) = m.last_damage.and_then(|(d, _)| d.attacker)
-            && let Some(creeper) = self.mobs.iter_mut().find(|o| o.id == id)
-        {
+        if skulls && let Some(Who::Mob(id)) = m.last_damage.and_then(|(d, _)| d.attacker) {
             // Creeper.droppedSkulls: one head per charged explosion.
-            creeper.extra.charged = false;
+            self.combat.charged_exploders.retain(|c| *c != id);
+            if let Some(creeper) = self.mobs.iter_mut().find(|o| o.id == id) {
+                creeper.extra.charged = false;
+            }
         }
         let raider = horizon_client::mobs::raider::is_raider(m.species());
         for d in items {
@@ -838,11 +924,85 @@ impl Game<'_> {
             }
         }
     }
+    /// `InfestedMobEffect.onMobHurt` for a mob: silverfish from half its height up.
+    pub(super) fn mob_infested(&mut self, mob: u32) {
+        if let Some(m) = self.mobs.iter().find(|m| m.id == mob) {
+            let at = [
+                m.position.x,
+                m.position.y + f64::from(m.height()) / 2.0,
+                m.position.z,
+            ];
+            let look = m.view_vector();
+            self.infested_hurt(at, look, Some(mob));
+        }
+    }
+    /// `LivingEntity.dropFromGiftLootTable`: the gift table from its random
+    /// sequence with the mob as `this` (a chicken's egg depends on its
+    /// variant); the loot data of the game's resources decides, and without it
+    /// the items' table engine (no entity) rolls it.
+    fn drop_gift_loot(&mut self, mob: u32, table: &'static str, at: [f64; 3]) {
+        use horizon_client::mobs::drops;
+        use horizon_world::loot::EntityLootParams;
+        let loot = horizon_client::structure_blocks::loot_data(&self.options.resources);
+        let this = self
+            .mobs
+            .iter()
+            .find(|m| m.id == mob)
+            .map(|m| drops::loot_entity(m, None));
+        let stacks = match (loot, this) {
+            (Some(loot), Some(this)) if loot.has_table(table) => {
+                let params = EntityLootParams {
+                    this,
+                    ..EntityLootParams::default()
+                };
+                let seed = self.level.seed;
+                match loot.random_sequence(table) {
+                    Some(id) => {
+                        let random = self.rand_sequences.get(id, seed);
+                        loot.roll_entity(table, random, &params)
+                            .iter()
+                            .filter(|s| !s.is_empty())
+                            .map(from_loot)
+                            .collect()
+                    }
+                    None => Vec::new(),
+                }
+            }
+            _ => self
+                .res
+                .items()
+                .loot_table(table, false, None, &mut self.world.random),
+        };
+        for d in stacks {
+            self.spawn_item(d, at, [0.0, 0.2, 0.0], 10);
+        }
+    }
+    /// Adds a projectile, giving it an id from the entity counter
+    /// (`Entity.id`, the same counter as the rest) when it has none.
+    pub(super) fn add_projectile(&mut self, mut p: horizon_client::projectiles::Projectile) {
+        if p.id == 0 {
+            self.next_entity += 1;
+            p.id = self.next_entity;
+        }
+        self.creatures.projectiles.push(p);
+    }
     pub(super) fn handle_mob_events(&mut self, events: Vec<MobEvent>) -> Result<()> {
         for e in events {
             match e {
                 MobEvent::SquidCycle { mob, at } => self.lan_entity_event(mob as i32, 19, at),
                 MobEvent::RabbitHop { mob, at } => self.lan_entity_event(mob as i32, 1, at),
+                MobEvent::Drown { mob, at } => {
+                    self.lan_entity_event(mob as i32, super::combat::DROWN_EVENT, at);
+                    let v = self
+                        .mobs
+                        .iter()
+                        .find(|m| m.id == mob)
+                        .map_or([0.0; 3], |m| [m.velocity.x, m.velocity.y, m.velocity.z]);
+                    self.drown_particles(at, v);
+                }
+                MobEvent::EntityEvent { mob, event, at } => {
+                    self.lan_entity_event(mob as i32, event, at)
+                }
                 MobEvent::Sound(name, at, volume, pitch)
                 | MobEvent::LocalSound(name, at, volume, pitch) => {
                     self.audio
@@ -890,6 +1050,21 @@ impl Game<'_> {
                         }
                     }
                 }
+                MobEvent::Shift { target, delta } => {
+                    let d = Vec3::new(delta[0], delta[1], delta[2]);
+                    match target {
+                        Who::Player => {
+                            if let Some(p) = self.player.as_mut() {
+                                p.position = p.position.add_vector(d);
+                            }
+                        }
+                        Who::Mob(id) => {
+                            if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
+                                m.position = m.position.add_vector(d);
+                            }
+                        }
+                    }
+                }
                 MobEvent::Wololo { mob } => {
                     if let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) {
                         // DyeColor.RED.
@@ -903,21 +1078,36 @@ impl Game<'_> {
                     owner,
                 } => self.add_fangs(at, yaw, delay, owner),
                 MobEvent::Shoot(..) => {}
-                MobEvent::Explode(at, radius) => {
+                MobEvent::ExplosionSource { mob, charged } => {
+                    self.combat.explosion_source = Some(mob);
+                    if charged {
+                        self.combat.charged_exploders.push(mob);
+                    }
+                }
+                MobEvent::Explode(at, radius, species) => {
                     // The exploding mob causes the damage (Creeper.explodeCreeper).
-                    let source_mob = self
-                        .mobs
-                        .iter()
-                        .filter(|m| {
-                            (m.position.x - at[0]).powi(2) + (m.position.z - at[2]).powi(2) < 1.0
-                        })
-                        .map(|m| m.id)
-                        .next();
+                    let source_mob = self.combat.explosion_source.or_else(|| {
+                        self.mobs
+                            .iter()
+                            .filter(|m| {
+                                (m.position.x - at[0]).powi(2) + (m.position.z - at[2]).powi(2)
+                                    < 1.0
+                            })
+                            .map(|m| m.id)
+                            .next()
+                    });
                     if let Some(id) = source_mob {
                         self.note_attacker("minecraft:explosion", id);
                     }
                     self.combat.explosion_source = source_mob;
-                    let result = self.explode(at, radius);
+                    // Only a creeper or a wither empties the hives it blows up.
+                    // The creeper is already gone from the list, so the event
+                    // carries its kind.
+                    let result = if matches!(species, Species::Creeper | Species::Wither) {
+                        self.with_hive_emptying_blast(|g| g.explode(at, radius))
+                    } else {
+                        self.explode(at, radius)
+                    };
                     self.combat.explosion_source = None;
                     result?
                 }
@@ -928,6 +1118,7 @@ impl Game<'_> {
                 } => {
                     let mut killed = false;
                     let mut hurt = false;
+                    let mut infested = false;
                     if let Some(t) = self.mobs.iter_mut().find(|m| m.id == target) {
                         let hit = t.damage(amount, source);
                         hurt = hit;
@@ -936,17 +1127,27 @@ impl Game<'_> {
                             // The hurt or death sound the mob raised.
                             let center = t.center();
                             for event in std::mem::take(&mut t.outbox) {
-                                if let MobEvent::Sound(s, _, volume, pitch) = event {
-                                    self.audio.play(
-                                        &format!("minecraft:{s}"),
-                                        Some(center),
-                                        volume,
-                                        pitch,
-                                    );
+                                match event {
+                                    MobEvent::Sound(s, _, volume, pitch) => {
+                                        self.audio.play(
+                                            &format!("minecraft:{s}"),
+                                            Some(center),
+                                            volume,
+                                            pitch,
+                                        );
+                                    }
+                                    MobEvent::Infested { .. } => infested = true,
+                                    other => {
+                                        // Left for the end of the tick.
+                                        t.outbox.push(other);
+                                    }
                                 }
                             }
                         }
                     }
+                    if infested {
+                        self.mob_infested(target);
+                    }
                     if hurt
                         && let Some(Who::Mob(attacker)) = source.attacker
                         && let Some(m) = self
@@ -992,6 +1193,7 @@ impl Game<'_> {
                 }
                 MobEvent::BecomeStatue { mob } => self.golem_become_statue(mob),
                 MobEvent::EnterHive { mob, hive } => self.bee_enter_hive(mob, hive),
+                MobEvent::Infested { mob } => self.mob_infested(mob),
                 MobEvent::Gift { target, item } => {
                     if let Some(m) = self.mobs.iter_mut().find(|m| m.id == target)
                         && m.saddle_item().is_none()
@@ -1013,7 +1215,12 @@ impl Game<'_> {
                     self.next_entity += 1;
                     p.id = self.next_entity;
                     let (owner, at) = (p.owner, [p.position.x, p.position.y, p.position.z]);
-                    self.creatures.projectiles.push(p);
+                    // LlamaSpit.recreateFromPacket: the spit's burst on the client.
+                    if p.kind == ProjectileKind::LlamaSpit {
+                        let v = p.velocity;
+                        self.particles.llama_spit_burst(at, [v.x, v.y, v.z]);
+                    }
+                    self.add_projectile(p);
                     self.projectile_event("minecraft:projectile_shoot", owner, at);
                 }
                 MobEvent::Spawn(mut m) => {
@@ -1037,14 +1244,48 @@ impl Game<'_> {
                     [0.0, 0.2, 0.0],
                     10,
                 ),
-                MobEvent::SetBlock { pos, state } => {
-                    self.world.set(pos[0], pos[1], pos[2], state)?
-                }
+                // `Level.setBlockAndUpdate`: neighbour and shape updates, so a crop
+                // above trampled farmland breaks and drops.
+                MobEvent::SetBlock { pos, state } => self.level_set(pos, state)?,
                 MobEvent::SetDoorOpen { pos, open } => {
                     let pos = BlockPos::new(pos[0], pos[1], pos[2]);
                     self.with_level(|b, level, ticks| b.set_door_open(level, ticks, pos, open));
                     self.process_level_events()?;
                 }
+                MobEvent::BreakDoor { pos } => {
+                    // BreakDoorGoal.tick: removeBlock, then level events 1021
+                    // and 2001 with the state that is there now.
+                    let air = self.world.air;
+                    let at = BlockPos::new(pos[0], pos[1], pos[2]);
+                    self.with_level(|b, level, ticks| b.set_block(level, ticks, at, air, 3));
+                    self.process_level_events()?;
+                    self.level_event_at(1021, pos, 0);
+                    let left = self.world.block(pos[0], pos[1], pos[2]);
+                    self.level_event_at(2001, pos, left.0 as i32);
+                }
+                MobEvent::DestroyProgress { mob, pos, progress } => {
+                    self.destroy_block_progress(mob as i32, pos, progress);
+                    // ServerLevel.destroyBlockProgress: every player nearby sees it.
+                    if let Some(host) = self.lan.as_ref() {
+                        host.hub.broadcast_near(
+                            [f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])],
+                            64.0,
+                            &horizon_protocol::packets::play::Clientbound::BlockDestruction(
+                                horizon_protocol::packets::play::BlockDestruction {
+                                    id: mob as i32,
+                                    pos,
+                                    progress: if (0..10).contains(&progress) {
+                                        progress as u8
+                                    } else {
+                                        255
+                                    },
+                                },
+                            ),
+                            None,
+                        );
+                    }
+                }
+                MobEvent::LevelEvent { id, pos, data } => self.level_event_at(id, pos, data),
                 MobEvent::SetBlockName { pos, name, effect } => {
                     if effect {
                         let old = self.world.block(pos[0], pos[1], pos[2]);
@@ -1116,19 +1357,24 @@ impl Game<'_> {
                     }
                 }
                 MobEvent::AroundSelf {
+                    mob,
+                    event,
                     kind,
                     feet,
                     width,
                     height,
                     burst,
-                } => self.particles_around(kind, feet, [width, height], burst),
+                } => {
+                    self.lan_entity_event(mob as i32, event, feet);
+                    self.particles_around(kind, feet, [width, height], burst)
+                }
                 MobEvent::ParticleAt { kind, at, velocity } => {
                     if let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) {
                         let options = horizon_client::particles::ParticleOptions::simple(ty);
                         self.particles.add(&options, at, velocity);
                     }
                 }
-                MobEvent::Experience { at, amount } => self.spawn_orbs(at, amount),
+                MobEvent::Experience { at, amount } => self.spawn_breeding_orb(at, amount),
                 MobEvent::AxolotlSupportPlayer => {
                     let previous = self
                         .potions
@@ -1190,6 +1436,10 @@ impl Game<'_> {
                     self.mob_vibration_particle(from, to, ticks)
                 }
                 MobEvent::DigParticles { at } => self.warden_dig_particles(at),
+                MobEvent::BlockBreakEffect { pos, block } => {
+                    let state = self.world.block(block[0], block[1], block[2]);
+                    self.destroy_particles(pos, state);
+                }
                 MobEvent::Darkness { at, radius } => self.apply_darkness(at, radius),
                 MobEvent::CreakingHurt {
                     home,
@@ -1200,12 +1450,14 @@ impl Game<'_> {
                     self.creaking_tear_down(center, spread)
                 }
                 MobEvent::CureZombieVillager { mob } => self.cure_zombie_villager(mob),
+                MobEvent::Reinforcements { mob, target } => self.call_reinforcements(mob, target),
                 MobEvent::VillagerMeet { mob, other } => self.villager_meet(mob, other),
                 MobEvent::VillagerBirth {
                     parent,
                     partner,
                     child,
                 } => self.villager_birth(parent, partner, child),
+                MobEvent::WorkAtComposter { mob, pos } => self.villager_work_at_composter(mob, pos),
                 MobEvent::GolemCheck { mob, needed } => self.villager_golem_check(mob, needed),
                 MobEvent::Firework { at, color, flight } => {
                     self.villager_firework(at, color, flight)
@@ -1226,19 +1478,67 @@ impl Game<'_> {
                         m.ai.aggressive |= aggressive;
                     }
                 }
-                MobEvent::GiftLoot { table, at } => {
-                    let drops =
-                        self.res
-                            .items()
-                            .loot_table(table, false, None, &mut self.world.random);
+                MobEvent::ShedScute { mob, at, pitch } => {
+                    // The mob already checked `shouldDropLoot` (a baby, `mob_drops`).
+                    let table = "minecraft:gameplay/armadillo_shed";
+                    let drops = self.sequence_loot(table, table, None);
                     for d in drops {
-                        self.spawn_item(d, at, [0.0, 0.2, 0.0], 10);
+                        self.spawn_at_location(Vec3::new(at[0], at[1], at[2]), 0.0, d);
                     }
+                    self.audio.play(
+                        "minecraft:entity.armadillo.scute_drop",
+                        Some(at),
+                        1.0,
+                        pitch,
+                    );
+                    let ctx = self.who_context(Some(Who::Mob(mob)), None);
+                    self.post_game_event("minecraft:entity_place", at, ctx);
+                }
+                MobEvent::GiftLoot { mob, table, at } => {
+                    // Turtle.ageBoundaryReached: only with mob loot on.
+                    if table == "minecraft:gameplay/turtle_grow" && !self.ui.rules.bool("mob_drops")
+                    {
+                        continue;
+                    }
+                    self.drop_gift_loot(mob, table, at);
                 }
             }
         }
         Ok(())
     }
+    /// `TurtleEggBlock.randomTick` at the last hatch stage: one baby turtle
+    /// per egg, a day from grown, with the egg as its home (the sound, the
+    /// crumbs and the block's removal came from the level).
+    pub(super) fn hatch_turtles(
+        &mut self,
+        pos: [i32; 3],
+        state: horizon_world::registry::BlockStateId,
+    ) {
+        let eggs = self
+            .pack
+            .assets
+            .registry
+            .state(state)
+            .and_then(|s| s.properties.get("eggs"))
+            .and_then(|v| v.parse::<i32>().ok())
+            .unwrap_or(1);
+        for i in 0..eggs {
+            let at = [
+                f64::from(pos[0]) + 0.3 + f64::from(i) * 0.2,
+                f64::from(pos[1]),
+                f64::from(pos[2]) + 0.3,
+            ];
+            if let Some(id) = self.spawn_mob("minecraft:turtle", at, true)
+                && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id)
+            {
+                m.extra.age = -24000;
+                m.extra.home = Some(pos);
+                m.yaw = 0.0;
+                m.body_yaw = 0.0;
+                m.head_yaw = 0.0;
+            }
+        }
+    }
     fn apply_setup(&mut self, id: u32, setup: &SpawnSetup) {
         let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) else {
             return;
@@ -1272,6 +1572,13 @@ impl Game<'_> {
             m.extra.egg_time = life;
         }
     }
+    /// `Animal.finalizeSpawnChildFromBreeding`'s experience orb: only when the
+    /// `mob_drops` game rule is on.
+    fn spawn_breeding_orb(&mut self, at: [f64; 3], amount: u32) {
+        if self.ui.rules.bool("mob_drops") {
+            self.spawn_orbs(at, amount);
+        }
+    }
     /// Animal.spawnChildFromBreeding
     fn breed(
         &mut self,
@@ -1294,6 +1601,8 @@ impl Game<'_> {
                 .unwrap_or_else(|| parent.clone());
             let mut child = parent.clone();
             child.baby = true;
+            // TurtleBreedGoal.breed triggers it without a child.
+            let turtle = p.species() == Species::Turtle;
             if matches!(
                 (
                     p.species(),
@@ -1306,18 +1615,33 @@ impl Game<'_> {
             ) {
                 child.kind = "minecraft:mule".into();
             }
-            self.trigger_bred(&parent, &partner_view, Some(&child));
+            self.trigger_bred(&parent, &partner_view, (!turtle).then_some(&child));
         }
         if let Some(q) = self.mobs.iter_mut().find(|m| m.id == partner) {
             q.extra.age = 6000;
             q.extra.in_love = 0;
         }
         let q = self.mobs.iter().find(|m| m.id == partner).cloned();
+        // Animal.finalizeSpawnChildFromBreeding: entity event 18 for the parent.
+        self.mob_event_particles(parent, 18);
         // Sniffer.spawnChildFromBreeding: an egg instead of a baby.
         if p.species() == Species::Sniffer {
             self.lay_sniffer_egg(&p);
             return;
         }
+        // TurtleBreedGoal.breed: the goal gave the mother her egg; only the
+        // experience is left, and only with mob loot on.
+        if p.species() == Species::Turtle {
+            // One `new ExperienceOrb` of 1 to 7 from the mother's random (not
+            // split up as `ExperienceOrb.award` does).
+            if self.ui.rules.bool("mob_drops")
+                && let Some(m) = self.mobs.iter_mut().find(|m| m.id == parent)
+            {
+                let xp = 1 + m.random.next_int_bound(7).unwrap_or(0) as u32;
+                self.add_orb([p.position.x, p.position.y, p.position.z], xp);
+            }
+            return;
+        }
         let coin = self.world.random.next_int_bound(2).unwrap_or(0) == 0;
         let coin2 = self.world.random.next_int_bound(2).unwrap_or(0) == 0;
         // A horse and a donkey have a mule.
@@ -1365,7 +1689,7 @@ impl Game<'_> {
                 }
                 self.world.random = r;
                 let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
-                self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+                self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp);
                 return;
             }
             if p.species() == Species::Cat {
@@ -1386,7 +1710,7 @@ impl Game<'_> {
                     };
                 }
                 let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
-                self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+                self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp);
                 return;
             }
             if p.species() == Species::Wolf {
@@ -1408,7 +1732,7 @@ impl Game<'_> {
                     };
                 }
                 let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
-                self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+                self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp);
                 return;
             }
             // Nautilus.getBreedOffspring: a tame parent's baby is tame too.
@@ -1424,7 +1748,7 @@ impl Game<'_> {
             }
         }
         let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
-        self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+        self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp);
     }
     /// `MobEffectUtil.addEffectToPlayersAround` for an elder guardian:
     /// mining fatigue III for five minutes unless a stronger or longer one
@@ -1481,11 +1805,34 @@ impl Game<'_> {
     pub(super) fn mob_hits_player_kind(&mut self, amount: f32, from: [f64; 3], kind: &str) {
         self.mob_hits_player(amount, from, kind);
     }
+    /// Damage whose causing mob is known (`cause`, or none): not guessed
+    /// from the mob nearest to `from`.
+    pub(super) fn mob_hits_player_caused(
+        &mut self,
+        amount: f32,
+        from: [f64; 3],
+        kind: &str,
+        cause: Option<u32>,
+    ) {
+        self.hurt_player_from(amount, Some(from), kind, Some(cause));
+    }
     pub(super) fn mob_hits_player(
         &mut self,
         amount: f32,
         from: [f64; 3],
         damage_type: &str,
+    ) -> bool {
+        self.hurt_player_from(amount, Some(from), damage_type, None)
+    }
+    /// `hurtServer` on the player. `from` is the source's position (none: no
+    /// direction), `known`: the causing mob when it is given (`/damage`),
+    /// else the melee attacker is the mob nearest to `from`.
+    pub(super) fn hurt_player_from(
+        &mut self,
+        amount: f32,
+        from: Option<[f64; 3]>,
+        damage_type: &str,
+        known: Option<Option<u32>>,
     ) -> bool {
         // ServerPlayer.canHarmPlayer refused another player's projectile.
         if self.creative || self.combat.refuse_player_hit {
@@ -1498,37 +1845,44 @@ impl Game<'_> {
             .damage_tags
             .get("minecraft:is_projectile")
             .is_some_and(|t| t.contains(damage_type));
-        let blocking = self.player_blocking(Some(from), damage_type, false);
+        let blocking = self.player_blocking(from, damage_type, false);
         let raised = blocking.is_some();
         // Melee: the attacker stands at `from` (another player's hit has no mob behind it).
-        let attacker = (!projectile && damage_type != "minecraft:player_attack")
-            .then(|| {
-                self.mobs
-                    .iter()
-                    .filter(|m| m.alive())
-                    .min_by(|a, b| {
-                        let d = |m: &horizon_client::mobs::Mob| {
-                            (m.position.x - from[0]).powi(2) + (m.position.z - from[2]).powi(2)
-                        };
-                        d(a).total_cmp(&d(b))
-                    })
-                    .map(|m| m.id)
-            })
-            .flatten();
+        let attacker = match known {
+            Some(known) => known,
+            None => from
+                .filter(|_| !projectile && damage_type != "minecraft:player_attack")
+                .and_then(|from| {
+                    self.mobs
+                        .iter()
+                        .filter(|m| m.alive())
+                        .min_by(|a, b| {
+                            let d = |m: &horizon_client::mobs::Mob| {
+                                (m.position.x - from[0]).powi(2) + (m.position.z - from[2]).powi(2)
+                            };
+                            d(a).total_cmp(&d(b))
+                        })
+                        .map(|m| m.id)
+                }),
+        };
         // The causing entity for the death message.
         let owner = self.combat.projectile_owner.take();
         if let Some(a) = attacker.or(owner) {
             self.note_attacker(damage_type, a);
         }
+        // DamageSource.scalesWithDifficulty: a mob (or its projectile's
+        // owner) caused the hit, not a player.
+        let living_cause = attacker.or(owner).is_some();
         let mut outcome = horizon_client::health::BlockOutcome::default();
         if let Some(player) = self.player.as_mut()
             && let Some(id) = self.motion.health.damage.id(damage_type)
-            && let Ok(o) = player.hurt_blocking(
+            && let Ok(o) = player.hurt_caused_by(
                 &self.motion.health,
                 self.world.health_rules,
                 id,
                 amount,
                 blocking,
+                living_cause,
             )
             && {
                 outcome = o;
@@ -1538,7 +1892,14 @@ impl Game<'_> {
             // LivingEntity.hurtServer's dealDefaultKnockback: not inside the
             // hurt cooldown (a stronger hit there only adds its difference).
             if o.knockback {
-                let (xd, zd) = (from[0] - player.position.x, from[2] - player.position.z);
+                // No source position: a random direction.
+                let (xd, zd) = from.map_or((0.0, 0.0), |from| {
+                    (from[0] - player.position.x, from[2] - player.position.z)
+                });
+                // dealDefaultKnockback's `indicateDamage`, unless blocked.
+                if o.blocked <= 0.0 {
+                    player.health.indicate_damage(xd, zd, player.yaw);
+                }
                 self.knock_back_player(f64::from(0.4_f32), xd, zd);
                 if let Some(p) = self.player.as_mut()
                     && let Some(r) = p.hurt_log.last_mut()
@@ -1546,12 +1907,28 @@ impl Game<'_> {
                     r.knockback = Some([p.velocity.x, p.velocity.y, p.velocity.z]);
                 }
             }
-            self.hurt_armor(amount);
             // The thorns hurt the entity that caused the hit, if there is one.
             if let Some(a) = attacker.or(owner) {
                 self.thorns(a);
             }
         }
+        // LivingEntity.hurtServer: ENTITY_HURT_PLAYER, unless it returned
+        // early (invulnerable, or inside the hurt cooldown).
+        if outcome.hurt || outcome.sound {
+            let source = attacker
+                .or(owner)
+                .and_then(|id| self.mobs.iter().find(|m| m.id == id))
+                .map(|m| self.mob_entity(m));
+            self.trigger_entity_hurt_player(&horizon_client::advancements::DamageView {
+                kind: damage_type.to_owned(),
+                direct: source.clone().filter(|_| !projectile),
+                is_direct: !projectile,
+                source,
+                original: amount,
+                actual: amount - outcome.blocked,
+                blocked: outcome.blocked > 0.0,
+            });
+        }
         if raised {
             self.after_block(outcome, amount, attacker, projectile);
         }
@@ -1688,6 +2065,7 @@ impl Game<'_> {
         let mut hits = Vec::new();
         let mut deflections: Vec<[f64; 3]> = Vec::new();
         let mut arrow_events = Vec::new();
+        let mut trails = Vec::new();
         {
             let mut targets: Vec<(Who, Aabb)> = self
                 .mobs
@@ -1779,6 +2157,25 @@ impl Game<'_> {
                 if shooter.is_some() {
                     p.owner = Some(Who::Player);
                 }
+                // AbstractHurtingProjectile.tick ends with createParticleTrail.
+                if super::remote_projectiles::has_smoke_trail(&p.kind) {
+                    trails.push(p.position);
+                }
+                // ThrownEnderpearl.onAboveBubbleColumn / onInsideBubbleColumn.
+                if keep && hit == Hit::None && matches!(p.kind, ProjectileKind::EnderPearl) {
+                    let (at, h) = (p.position, 0.125);
+                    horizon_client::motion::bubble_column_push(
+                        w.world,
+                        w.registry,
+                        w.facts,
+                        w.collision,
+                        Aabb::new(
+                            Vec3::new(at.x - h, at.y, at.z - h),
+                            Vec3::new(at.x + h, at.y + 2.0 * h, at.z + h),
+                        ),
+                        &mut p.velocity,
+                    );
+                }
                 if let Some(a) = p.arrow.as_mut() {
                     arrow_events.extend(a.events.drain(..).map(|e| (p.position, e)));
                 }
@@ -1821,6 +2218,7 @@ impl Game<'_> {
                 keep
             });
         }
+        self.smoke_trails(trails);
         for at in deflections {
             self.audio
                 .play("minecraft:entity.breeze.deflect", Some(at), 1.0, 1.0);
@@ -1853,6 +2251,7 @@ impl Game<'_> {
                 _ => self.projectile_hit(&p, hit)?,
             }
         }
+        self.flush_lan_explosions();
         self.flush_wind_bursts()
     }
     /// `projectile_hit` for a projectile the guest `conn` shot, run as them;
@@ -1877,6 +2276,33 @@ impl Game<'_> {
             None => self.projectile_hit(p, hit),
         }
     }
+    /// What an arrow or a thrown trident hits an entity of type `victim`
+    /// for (`AbstractArrow.onHitEntity`, `ThrownTrident.onHitEntity`): a
+    /// trident's 8 through `EnchantmentHelper.modifyDamage` of the trident
+    /// (Impaling's `minecraft:damage` on `#sensitive_to_impaling`).
+    fn shot_damage(&mut self, shot: &mut Projectile, victim: Option<&str>) -> f32 {
+        if !matches!(shot.kind, ProjectileKind::Trident) {
+            return arrow_damage(shot, &mut self.world.random) + shot.bonus.damage;
+        }
+        let Some(trident) = shot.arrow.as_ref().map(|a| a.pickup_item.clone()) else {
+            return 8.0;
+        };
+        let ctx = horizon_client::enchant::EffectContext {
+            this: victim,
+            attacker: (shot.owner == Some(Who::Player)).then_some("minecraft:player"),
+            direct_attacker: Some("minecraft:trident"),
+            damage_type: Some("minecraft:trident"),
+            items: Some(self.res.items()),
+            ..Default::default()
+        };
+        self.res.stations().enchantments.modify_value(
+            Some(&trident),
+            "minecraft:damage",
+            &ctx,
+            &mut self.world.random,
+            8.0,
+        )
+    }
     /// What an arrow's tick asked for: its particles and sounds.
     fn arrow_event(&mut self, at: Vec3, event: horizon_client::arrows::ArrowEvent) {
         use horizon_client::arrows::{ArrowEvent, ArrowParticle, ArrowSound, BlockReaction};
@@ -1905,6 +2331,8 @@ impl Game<'_> {
                     ArrowSound::Splash => "minecraft:entity.generic.splash",
                     ArrowSound::HitGround => "minecraft:entity.arrow.hit",
                     ArrowSound::Extinguish => "minecraft:entity.generic.extinguish_fire",
+                    ArrowSound::TridentHitGround => "minecraft:item.trident.hit_ground",
+                    ArrowSound::TridentHit => "minecraft:item.trident.hit",
                 };
                 self.audio
                     .play(name, Some([at.x, at.y, at.z]), volume, pitch);
@@ -1956,11 +2384,9 @@ impl Game<'_> {
             ArrowEvent::ShootEvent | ArrowEvent::Drop => {}
         }
     }
-    /// `Level.isRainingAt` for arrows: raining, open to the sky (the biome's
-    /// precipitation is not checked here).
+    /// `Level.isRainingAt` for arrows.
     fn arrow_rain(&self) -> impl Fn(BlockPos) -> bool + '_ {
-        let raining = self.world.weather.levels(1.0).0 > 0.2;
-        move |p: BlockPos| raining && self.world.light(p.x, p.y, p.z) >> 4 == 15
+        move |p: BlockPos| self.raining_at(p)
     }
     /// The level as arrows see it.
     fn arrow_scene<'s>(
@@ -1998,7 +2424,24 @@ impl Game<'_> {
             }
         }
         if keep {
-            self.creatures.projectiles.push(arrow);
+            self.add_projectile(arrow);
+        }
+    }
+    /// `TargetBlock.onProjectileHit`: a target block takes its power from
+    /// where the projectile landed and resets after 20 ticks for an arrow, 8
+    /// for any other projectile. A player's shot counts as a target hit.
+    fn target_block_hit(&mut self, p: &Projectile, pos: [i32; 3], at: Vec3, face: [i32; 3]) {
+        let block = BlockPos::new(pos[0], pos[1], pos[2]);
+        let arrow = p.arrow.is_some();
+        let location = [at.x, at.y, at.z];
+        let hit = self.with_level(|b, level, ticks| {
+            b.target_projectile_hit(level, ticks, block, location, face, arrow)
+        });
+        if hit.is_some() {
+            let _ = self.process_level_events();
+            if p.owner == Some(Who::Player) {
+                self.stats.custom("target_hit", 1);
+            }
         }
     }
     pub(super) fn projectile_hit(&mut self, p: &Projectile, hit: Hit) -> Result<()> {
@@ -2010,6 +2453,13 @@ impl Game<'_> {
             Hit::Entity { at, .. } | Hit::Block { at, .. } => at,
             Hit::None => return Ok(()),
         };
+        // Projectile.onHitBlock: BlockState.onProjectileHit, for every
+        // projectile (a wind charge out of the world's top has no face).
+        if let Hit::Block { pos, face, .. } = hit
+            && face != [0; 3]
+        {
+            self.target_block_hit(p, pos, at, face);
+        }
         if let Hit::Entity {
             who: Who::Mob(id),
             at,
@@ -2030,11 +2480,11 @@ impl Game<'_> {
             && id >= super::dragon::SPECIAL
         {
             let by_player = p.owner == Some(Who::Player);
-            if let ProjectileKind::Arrow { .. } = p.kind {
+            if p.arrow.is_some() {
                 // AbstractArrow.onHitEntity: spent if the part or crystal took
                 // it, else turned back (a perched dragon sets it alight first).
                 let mut arrow = p.clone();
-                let amount = arrow_damage(&mut arrow, &mut self.world.random) + p.bonus.damage;
+                let amount = self.shot_damage(&mut arrow, None);
                 let outcome = match self.hit_special(id, amount, by_player, true) {
                     super::dragon::Hurt::Landed { .. } => EntityHit::Hurt,
                     super::dragon::Hurt::Refused => EntityHit::Refused,
@@ -2055,17 +2505,15 @@ impl Game<'_> {
             self.hit_special(id, amount, by_player, false);
             return Ok(());
         }
-        if let (
-            ProjectileKind::Arrow { .. },
-            Hit::Entity {
+        if p.arrow.is_some()
+            && let Hit::Entity {
                 who: Who::Mob(id), ..
-            },
-        ) = (&p.kind, hit)
+            } = hit
             && let Some(i) = self.carts.iter().position(|c| c.id == id)
         {
             // AbstractArrow.onHitEntity on a minecart.
             let mut arrow = p.clone();
-            let amount = arrow_damage(&mut arrow, &mut self.world.random) + p.bonus.damage;
+            let amount = self.shot_damage(&mut arrow, None);
             let burning = p.arrow.as_ref().is_some_and(|a| a.on_fire());
             let creative = p.owner == Some(Who::Player) && self.creative;
             self.arrow_hits_cart(i, amount, p.velocity, burning, creative);
@@ -2076,7 +2524,7 @@ impl Game<'_> {
         // Projectile.onHit: the landing is heard.
         self.projectile_event("minecraft:projectile_land", p.owner, atp);
         let source_kind = match p.kind {
-            ProjectileKind::Arrow { .. } => DamageKind::Arrow,
+            ProjectileKind::Arrow { .. } | ProjectileKind::Trident => DamageKind::Arrow,
             ProjectileKind::SmallFireball | ProjectileKind::LargeFireball { .. } => {
                 DamageKind::Fireball
             }
@@ -2088,6 +2536,40 @@ impl Game<'_> {
             from: Some([p.previous.x, p.previous.y, p.previous.z]),
         };
         match (&p.kind, hit) {
+            // ThrownTrident.onHitEntity: 8 damage (Impaling on aquatic mobs),
+            // dealt whether or not the hurt lands, then it bounces off.
+            (ProjectileKind::Trident, Hit::Entity { who, .. }) => {
+                let mut trident = p.clone();
+                let victim = match who {
+                    Who::Mob(id) => self
+                        .mobs
+                        .iter()
+                        .find(|m| m.id == id)
+                        .map(|m| m.kind.id.clone()),
+                    Who::Player => Some("minecraft:player".to_owned()),
+                };
+                let amount = self.shot_damage(&mut trident, victim.as_deref());
+                let hurt = match who {
+                    Who::Player => self.mob_hits_player(
+                        amount,
+                        [p.previous.x, p.previous.y, p.previous.z],
+                        "minecraft:trident",
+                    ),
+                    Who::Mob(id) => self
+                        .mobs
+                        .iter_mut()
+                        .find(|m| m.id == id)
+                        .is_some_and(|m| m.damage(amount, source)),
+                };
+                let outcome = if hurt {
+                    EntityHit::Hurt
+                } else {
+                    EntityHit::Refused
+                };
+                self.finish_arrow_hit(trident, outcome);
+            }
+            // AbstractArrow.onHitBlock plays its sound itself (ArrowEvent).
+            (ProjectileKind::Trident, Hit::Block { .. }) => {}
             (ProjectileKind::Arrow { effect, .. }, Hit::Entity { who, .. }) => {
                 let mut arrow = p.clone();
                 let amount = arrow_damage(&mut arrow, &mut self.world.random) + p.bonus.damage;
@@ -2119,14 +2601,46 @@ impl Game<'_> {
                             .is_some_and(|m| m.damage(amount, source));
                         if p.owner == Some(Who::Player) {
                             self.last_hurt_by_player.insert(id, self.lan_acting);
+                            if hurt && let Some(m) = self.mobs.iter().find(|m| m.id == id) {
+                                // LivingEntity.hurtServer: PLAYER_HURT_ENTITY.
+                                let victim = self.mob_entity(m);
+                                let spectral = p.arrow.as_ref().is_some_and(|a| {
+                                    &*a.pickup_item.item == "minecraft:spectral_arrow"
+                                });
+                                let direct = horizon_client::advancements::EntityView {
+                                    kind: if spectral {
+                                        "minecraft:spectral_arrow"
+                                    } else {
+                                        "minecraft:arrow"
+                                    }
+                                    .into(),
+                                    position: [p.position.x, p.position.y, p.position.z],
+                                    ..Default::default()
+                                };
+                                self.player_hit(&victim, "minecraft:arrow", Some(direct), amount);
+                            }
                         }
                         hurt
                     }
                 };
-                // doKnockback: Punch pushes along the flight.
+                // doKnockback: Punch pushes along the flight, less the target's
+                // knockback resistance.
                 let flight = (p.velocity.x * p.velocity.x + p.velocity.z * p.velocity.z).sqrt();
-                if hurt && p.bonus.punch > 0 && flight > 1e-6 {
-                    let k = f64::from(p.bonus.punch) * 0.6 / flight;
+                let resistance = match who {
+                    Who::Player => self
+                        .player
+                        .as_mut()
+                        .and_then(|pl| pl.attribute("minecraft:knockback_resistance").ok())
+                        .unwrap_or(0.0),
+                    Who::Mob(id) => self
+                        .mobs
+                        .iter()
+                        .find(|m| m.id == id)
+                        .map_or(0.0, |m| m.attrs.knockback_resistance),
+                };
+                let push = f64::from(p.bonus.punch) * 0.6 * (1.0 - resistance).max(0.0);
+                if hurt && push > 0.0 && flight > 1e-6 {
+                    let k = push / flight;
                     self.handle_mob_events(vec![MobEvent::Push {
                         target: who,
                         velocity: [p.velocity.x * k, 0.1, p.velocity.z * k],
@@ -2162,6 +2676,7 @@ impl Game<'_> {
                     };
                     m.damage(amount, source);
                 }
+                self.thrown_break_event(p.id, atp);
                 self.item_burst(atp, "minecraft:snowball");
             }
             (ProjectileKind::Egg, hit) => {
@@ -2187,6 +2702,7 @@ impl Game<'_> {
                         }
                     }
                 }
+                self.thrown_break_event(p.id, atp);
                 self.item_burst(atp, "minecraft:egg");
             }
             (ProjectileKind::EnderPearl, hit) => {
@@ -2290,7 +2806,10 @@ impl Game<'_> {
                 if let Some(owner) = self.combat.projectile_owner {
                     self.note_attacker("minecraft:explosion", owner);
                 }
-                self.explode(atp, *power as f32)?;
+                self.combat.explosion_owner = self.combat.projectile_owner;
+                let result = self.explode(atp, *power as f32);
+                self.combat.explosion_owner = None;
+                result?;
             }
             (
                 ProjectileKind::Potion {
@@ -2309,14 +2828,30 @@ impl Game<'_> {
                     if d2 < 16.0 && !self.creative {
                         let scale = 1.0 - d2.sqrt() / 4.0;
                         let t = (f64::from(*ticks) * scale + 0.5) as i32;
-                        if let Some(owner) = self.combat.projectile_owner {
-                            self.note_attacker("minecraft:indirect_magic", owner);
-                        }
                         match *effect {
-                            "minecraft:instant_damage" => self.hurt_player_by(
-                                "minecraft:indirect_magic",
-                                6.0 * (1 << *amplifier) as f32 * scale as f32,
-                            ),
+                            "minecraft:instant_damage" => {
+                                // indirectMagic(potion, owner), built where the
+                                // hurt happens: the thrower, or the potion
+                                // itself when it has none. A status effect
+                                // deals no damage, so it records no source.
+                                let owner = self
+                                    .combat
+                                    .projectile_owner
+                                    .filter(|id| self.mob_display_name(*id).is_some());
+                                match owner {
+                                    Some(owner) => {
+                                        self.note_attacker("minecraft:indirect_magic", owner)
+                                    }
+                                    None => self.note_direct_entity(
+                                        "minecraft:indirect_magic",
+                                        Text::translate("entity.minecraft.splash_potion", &[]),
+                                    ),
+                                }
+                                self.hurt_player_by(
+                                    "minecraft:indirect_magic",
+                                    6.0 * (1 << *amplifier) as f32 * scale as f32,
+                                )
+                            }
                             e if t > 20 => self.give_player_effect(e, t, *amplifier),
                             _ => {}
                         }
@@ -2372,12 +2907,14 @@ impl Game<'_> {
             // ShulkerBullet.onHitEntity: 4 damage, then levitation for 10 s.
             (ProjectileKind::ShulkerBullet { .. }, Hit::Entity { who, .. }) => match who {
                 Who::Player => {
-                    if !self.creative {
-                        self.mob_hits_player(
+                    // Only a hit that hurt (`wasHurt`) brings the levitation.
+                    if !self.creative
+                        && self.mob_hits_player(
                             4.0,
                             [p.previous.x, p.previous.y, p.previous.z],
                             "minecraft:mob_projectile",
-                        );
+                        )
+                    {
                         self.give_player_effect("minecraft:levitation", 200, 0);
                     }
                 }
@@ -2386,6 +2923,8 @@ impl Game<'_> {
                         && m.damage(4.0, source)
                     {
                         m.extra.levitation = 200;
+                        // Shulker.hurtServer: a shulker hit by a bullet.
+                        horizon_client::mobs::shulker::hit_by_bullet(m);
                     }
                 }
             },
@@ -2416,10 +2955,17 @@ impl Game<'_> {
         }
         Ok(())
     }
+    /// `Snowball`/`ThrownEgg.onHit`: entity event 3 for the guests, before the
+    /// projectile is discarded (the clients lose it when the tracker next runs).
+    fn thrown_break_event(&mut self, id: u32, at: [f64; 3]) {
+        if id != 0 {
+            self.lan_entity_event(id as i32, 3, at);
+        }
+    }
     /// `Snowball`/`ThrownEgg.handleEntityEvent(3)`: eight crumbs of the
     /// thrown item where it broke, at rest for a snowball, scattered by the
     /// client entity's random (the particle engine's here) for an egg.
-    fn item_burst(&mut self, at: [f64; 3], item: &str) {
+    pub(super) fn item_burst(&mut self, at: [f64; 3], item: &str) {
         let options = self.item_particle(&horizon_client::items::ItemStack::new(item, 1));
         let egg = item != "minecraft:snowball";
         for _ in 0..8 {
@@ -2455,6 +3001,10 @@ impl Game<'_> {
         if self.name_mob(index) {
             return Ok(true);
         }
+        if self.spawn_egg_offspring(index) {
+            self.swing_arm();
+            return Ok(true);
+        }
         {
             let item = self.held().map(|h| h.item.to_string()).unwrap_or_default();
             if self.interact_leash(index, &item) {
@@ -2467,21 +3017,22 @@ impl Game<'_> {
             .as_ref()
             .map(|h| h.item.to_string())
             .unwrap_or_default();
+        // Bucketable.bucketMobPickup: a water bucket scoops up a fish, a
+        // tadpole or an axolotl, with the data its bucket carries.
         if item == "minecraft:water_bucket"
-            && self.mobs[index].species() == Species::Axolotl
             && self.mobs[index].alive()
+            && let Some((bucket, sound)) = bucketable(self.mobs[index].species())
         {
-            let mut filled = ItemStack::new("minecraft:axolotl_bucket", 1);
+            let mut filled = ItemStack::new(bucket, 1);
             filled.extra = Some(Box::new(horizon_client::entity_nbt::bucket_components(
                 &self.mobs[index],
             )));
-            self.audio.play(
-                "minecraft:item.bucket.fill_axolotl",
-                Some(self.mobs[index].center()),
-                1.0,
-                1.0,
-            );
+            self.audio
+                .play(sound, Some(self.mobs[index].center()), 1.0, 1.0);
             self.trigger_item("minecraft:filled_bucket", &filled);
+            // Leashable.dropLeash, then discard.
+            let id = self.mobs[index].id;
+            self.break_leash(id, true, false);
             self.mobs[index].removed = true;
             if self.creative {
                 if let Some(rest) = self.give(filled) {
@@ -2515,6 +3066,14 @@ impl Game<'_> {
             self.swing_arm();
             return Ok(true);
         }
+        if self.interact_armadillo(index, &item) {
+            if let Some(stack) = &held {
+                let target = self.mob_entity(&self.mobs[index]);
+                self.trigger_item_entity("minecraft:player_interacted_with_entity", stack, &target);
+            }
+            self.swing_arm();
+            return Ok(true);
+        }
         if self.interact_copper_golem(index, &item) {
             self.swing_arm();
             return Ok(true);
@@ -2535,6 +3094,20 @@ impl Game<'_> {
             }
             return Ok(true);
         }
+        // Creeper.mobInteract: any item in #creeper_igniters, damaged when it
+        // is damageable and used up otherwise.
+        let creeper_igniter = self
+            .res
+            .items()
+            .item_tags
+            .get("minecraft:creeper_igniters")
+            .is_some_and(|t| t.contains(&*item));
+        let damageable = self
+            .res
+            .items()
+            .get(&item)
+            .is_some_and(|i| i.max_damage > 0);
+        let acting = self.acting_player_uuid();
         let m = &mut self.mobs[index];
         if !m.alive() {
             return Ok(false);
@@ -2550,12 +3123,23 @@ impl Game<'_> {
         let mut handled = true;
         let mut drops: Vec<(String, u32)> = Vec::new();
         let is_food = m.kind.food.contains(&item);
+        let baby_turtle = species == Species::Turtle && m.is_baby();
         match species {
             Species::Cow | Species::Mooshroom if item == "minecraft:bucket" && !m.is_baby() => {
                 give = Some("minecraft:milk_bucket");
                 consume = true;
                 sound = Some("entity.cow.milk");
             }
+            // Goat.mobInteract: a bucket on an adult gives milk.
+            Species::Goat if item == "minecraft:bucket" && !m.is_baby() => {
+                give = Some("minecraft:milk_bucket");
+                consume = true;
+                sound = Some(if m.extra.screaming {
+                    "entity.goat.screaming.milk"
+                } else {
+                    "entity.goat.milk"
+                });
+            }
             Species::Mooshroom if item == "minecraft:bowl" && !m.is_baby() => {
                 give = Some("minecraft:mushroom_stew");
                 consume = true;
@@ -2628,6 +3212,7 @@ impl Game<'_> {
             }
             Species::Wolf
                 if m.extra.tame
+                    && m.extra.owner == Some(acting)
                     && item.ends_with("_dye")
                     && horizon_client::mobs::render::DYE_NAMES
                         .iter()
@@ -2650,7 +3235,9 @@ impl Game<'_> {
                 consume = true;
             }
             Species::Wolf
-                if m.extra.tame && !(is_food && m.extra.age == 0 && m.extra.in_love <= 0) =>
+                if m.extra.tame
+                    && m.extra.owner == Some(acting)
+                    && !(is_food && m.extra.age == 0 && m.extra.in_love <= 0) =>
             {
                 m.extra.sitting = !m.extra.sitting;
                 m.ai.jumping = false;
@@ -2670,20 +3257,14 @@ impl Game<'_> {
                 let tamed = m.random.next_int_bound(3).unwrap_or(1) == 0;
                 if tamed {
                     horizon_client::mobs::tame::set_tame(m, true);
-                    m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1]));
+                    m.extra.owner = Some(acting);
                     m.persistent = true;
                     m.nav_stop();
                     m.ai.target = None;
                     m.extra.sitting = true;
                 }
-                // TamableAnimal.spawnTamingParticles.
-                let kind = if tamed { "heart" } else { "smoke" };
                 // TamableAnimal.spawnTamingParticles (entity event 7 or 6).
-                self.particles_around_mob(
-                    self.mobs[index].id,
-                    kind,
-                    horizon_client::particles::Burst::TAMING,
-                );
+                self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 });
                 if tamed {
                     let view = self.mob_entity(&self.mobs[index]);
                     self.trigger_entity("minecraft:tame_animal", "entity", &view);
@@ -2697,6 +3278,7 @@ impl Game<'_> {
             // Cat.mobInteract: dye, heal or sit when tame; fish may tame a wild one.
             Species::Cat
                 if m.extra.tame
+                    && m.extra.owner == Some(acting)
                     && item.ends_with("_dye")
                     && horizon_client::mobs::render::DYE_NAMES
                         .iter()
@@ -2719,7 +3301,12 @@ impl Game<'_> {
                 m.persistent = true;
                 consume = true;
             }
-            Species::Cat if m.extra.tame && is_food && m.health < m.attrs.max_health => {
+            Species::Cat
+                if m.extra.tame
+                    && m.extra.owner == Some(acting)
+                    && is_food
+                    && m.health < m.attrs.max_health =>
+            {
                 let heal = self
                     .res
                     .items()
@@ -2732,7 +3319,9 @@ impl Game<'_> {
                 eat = eating_sound(m, &mut self.world.random);
             }
             Species::Cat
-                if m.extra.tame && !(is_food && m.extra.age == 0 && m.extra.in_love <= 0) =>
+                if m.extra.tame
+                    && m.extra.owner == Some(acting)
+                    && !(is_food && m.extra.age == 0 && m.extra.in_love <= 0) =>
             {
                 m.extra.sitting = !m.extra.sitting;
                 self.world.modified.insert((
@@ -2746,17 +3335,12 @@ impl Game<'_> {
                 let tamed = m.random.next_int_bound(3).unwrap_or(1) == 0;
                 if tamed {
                     m.extra.tame = true;
-                    m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1]));
+                    m.extra.owner = Some(acting);
                     m.extra.sitting = true;
                 }
                 eat = eating_sound(m, &mut self.world.random);
-                let kind = if tamed { "heart" } else { "smoke" };
                 // TamableAnimal.spawnTamingParticles (entity event 7 or 6).
-                self.particles_around_mob(
-                    self.mobs[index].id,
-                    kind,
-                    horizon_client::particles::Burst::TAMING,
-                );
+                self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 });
                 if tamed {
                     let view = self.mob_entity(&self.mobs[index]);
                     self.trigger_entity("minecraft:tame_animal", "entity", &view);
@@ -2775,10 +3359,21 @@ impl Game<'_> {
                 consume = true;
                 sound = Some("entity.iron_golem.repair");
             }
-            Species::Creeper if item == "minecraft:flint_and_steel" => {
+            Species::Creeper if creeper_igniter => {
                 m.extra.flag = true;
-                sound = Some("item.flintandsteel.use");
-                self.damage_held_tool();
+                // FIRECHARGE_USE for a fire charge, else FLINTANDSTEEL_USE,
+                // at the creeper's feet with a pitch from its own random.
+                let event = if item == "minecraft:fire_charge" {
+                    "item.firecharge.use"
+                } else {
+                    "item.flintandsteel.use"
+                };
+                eat = Some((event, 1.0, m.random.next_float() * 0.4 + 0.8));
+                if damageable {
+                    self.damage_held_tool();
+                } else {
+                    consume = true;
+                }
             }
             // Parrot.mobInteract: parrot food may tame a wild one (one time in
             // ten); a parrot never takes it as Animal food (isFood is false).
@@ -2793,18 +3388,26 @@ impl Game<'_> {
                     m.extra.tame = true;
                     m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1]));
                 }
-                let kind = if tamed { "heart" } else { "smoke" };
                 // TamableAnimal.spawnTamingParticles (entity event 7 or 6).
-                self.particles_around_mob(
-                    self.mobs[index].id,
-                    kind,
-                    horizon_client::particles::Burst::TAMING,
-                );
+                self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 });
                 if tamed {
                     let view = self.mob_entity(&self.mobs[index]);
                     self.trigger_entity("minecraft:tame_animal", "entity", &view);
                 }
             }
+            // Tadpole.feed: frog food ages it by a tenth of the time left to
+            // grow into a frog (it grows on its next tick once past 24000).
+            Species::Tadpole if is_food && !m.extra.age_locked => {
+                consume = true;
+                let left = 24_000 - m.extra.age;
+                m.extra.age += ((left / 20) as f32 * 0.1) as i32 * 20;
+                // One happy villager particle at rest about the body.
+                self.particles_around_mob(
+                    self.mobs[index].id,
+                    "happy_villager",
+                    horizon_client::particles::Burst::HORSE_EATING,
+                );
+            }
             // HappyGhast.canFallInLove: never, so only a ghastling takes food.
             _ if is_food
                 && m.kind.flags.animal
@@ -2817,6 +3420,11 @@ impl Game<'_> {
                     Some(sound) => {
                         consume = true;
                         eat = sound;
+                        // Animal.setInLove: entity event 18 (a baby that
+                        // only grew is not in love).
+                        if self.mobs[index].extra.in_love > 0 {
+                            self.mob_event_particles(self.mobs[index].id, 18);
+                        }
                     }
                     // Animal.mobInteract still consumes the client click when
                     // an adult cannot breed, without swinging or taking food.
@@ -2828,6 +3436,14 @@ impl Game<'_> {
         if !handled {
             return Ok(false);
         }
+        // Turtle.ageBoundaryReached: food that finishes a baby's growth.
+        if baby_turtle && !self.mobs[index].is_baby() {
+            self.handle_mob_events(vec![MobEvent::GiftLoot {
+                mob: self.mobs[index].id,
+                table: "minecraft:gameplay/turtle_grow",
+                at: feet,
+            }])?;
+        }
         self.swing_arm();
         if let Some(s) = sound {
             let pitch =
@@ -2884,6 +3500,50 @@ impl Game<'_> {
         }
         Ok(true)
     }
+    /// `Armadillo.mobInteract`: a brush brushes a scute off an adult
+    /// (`brushOffScute`) and loses 16 durability.
+    fn interact_armadillo(&mut self, index: usize, item: &str) -> bool {
+        let m = &self.mobs[index];
+        if item != "minecraft:brush"
+            || m.species() != Species::Armadillo
+            || !m.alive()
+            || m.is_baby()
+        {
+            return false;
+        }
+        let (id, at) = (m.id, m.position);
+        let feet = [at.x, at.y, at.z];
+        let tool = self.held().cloned();
+        let table = "minecraft:brush/armadillo";
+        for d in self.sequence_loot(table, table, tool.as_ref()) {
+            self.spawn_at_location(at, 0.0, d);
+        }
+        self.audio
+            .play("minecraft:entity.armadillo.brush", Some(feet), 1.0, 1.0);
+        let ctx = self.who_context(Some(Who::Mob(id)), None);
+        self.post_game_event("minecraft:entity_interact", feet, ctx);
+        // ItemStack.hurtAndBreak(16).
+        if !self.creative
+            && let Some(stack) = tool
+        {
+            let max = self
+                .res
+                .items()
+                .get(&stack.item)
+                .map_or(0, |i| i.max_damage);
+            if max > 0 {
+                let loss = self.durability_loss(&stack, 16);
+                let slot = self.held_slot();
+                if let Some(held) = self.stack_in_mut(slot).as_mut() {
+                    held.damage += loss;
+                    if held.damage >= max {
+                        *self.stack_in_mut(slot) = None;
+                    }
+                }
+            }
+        }
+        true
+    }
     pub(super) fn damage_held_tool(&mut self) {
         if self.creative {
             return;
@@ -2938,7 +3598,7 @@ impl Game<'_> {
             velocity,
             on_ground,
         );
-        self.creatures.projectiles.push(proj);
+        self.add_projectile(proj);
         self.player_projectile_shot();
         // ItemStack.use's applyAfterUseComponentSideEffects: the pearl's
         // second is the `use_cooldown` component, as for any thrown item.
@@ -2961,6 +3621,45 @@ impl Game<'_> {
         }
         Ok(true)
     }
+    /// `Mob.checkAndHandleImportantInteractions` with a spawn egg of mob
+    /// `index`'s own kind (`SpawnEggItem.spawnOffspringFromSpawnEgg`): a baby
+    /// at the mob's feet, taking the parent's variant as `getBreedOffspring`
+    /// does, and one egg used. False (PASS) when the mob has no baby form.
+    fn spawn_egg_offspring(&mut self, index: usize) -> bool {
+        let Some(stack) = self.held().cloned() else {
+            return false;
+        };
+        let parent = &self.mobs[index];
+        if !parent.alive()
+            || stack.item.strip_suffix("_spawn_egg") != Some(parent.kind.id.as_str())
+            || !horizon_client::mobs::drops::can_be_baby(parent.species())
+            // WanderingTrader.getBreedOffspring returns null: no offspring, the
+            // click carries on to trading.
+            || parent.species() == Species::WanderingTrader
+        {
+            return false;
+        }
+        let (kind, at) = (
+            parent.kind.id.clone(),
+            [parent.position.x, parent.position.y, parent.position.z],
+        );
+        let (species, variant, color) =
+            (parent.species(), parent.extra.variant, parent.extra.color);
+        let target = self.mob_entity(&self.mobs[index]);
+        let Some(id) = self.spawn_mob(&kind, at, true) else {
+            return false;
+        };
+        if let Some(child) = self.mobs.iter_mut().find(|m| m.id == id) {
+            horizon_client::mobs::finalize::set_baby(child, true);
+            child.extra.variant = variant;
+            if species == Species::Sheep {
+                child.extra.color = color;
+            }
+        }
+        self.trigger_item_entity("minecraft:player_interacted_with_entity", &stack, &target);
+        self.consume_held();
+        true
+    }
     fn use_spawn_egg(&mut self, stack: &ItemStack) -> Result<bool> {
         let Some(hit) = self.pick() else {
             return Ok(false);
@@ -3031,22 +3730,85 @@ impl Game<'_> {
             }
         }
     }
+    /// `Guardian.aiStep` on a client: two bubbles a tick trailing a guardian
+    /// that swims along, and bubbles up the beam to its target. The server
+    /// never draws them, so the mob's own random stays untouched.
+    pub(super) fn guardian_bubbles(&mut self) {
+        use horizon_client::mobs::guardian;
+        use horizon_client::particles::{ParticleOptions, ParticleType};
+        let mut swimming = Vec::new();
+        let mut beams = Vec::new();
+        for m in &self.mobs {
+            if !m.alive() || !matches!(m.species(), Species::Guardian | Species::ElderGuardian) {
+                continue;
+            }
+            let at = [m.position.x, m.position.y, m.position.z];
+            if m.extra.flag2 && m.fluids.in_water {
+                let (width, height, _) = m.dims();
+                swimming.push((at, width, height, m.view_vector()));
+            }
+            if let Some((_, scale)) = guardian::beam(m, 0.0)
+                && let Some(t) = self.beam_target(m.ai.target, 1.0)
+            {
+                beams.push(([at[0], m.eye_y(), at[2]], [t.x, t.y, t.z], f64::from(scale)));
+            }
+        }
+        let bubble = ParticleOptions::simple(ParticleType::Bubble);
+        for (at, width, height, view) in swimming {
+            for _ in 0..2 {
+                let (x, y, z) = {
+                    let r = self.particles.random();
+                    (r.next_double(), r.next_double(), r.next_double())
+                };
+                let p = [
+                    at[0] + width * (2.0 * x - 1.0) * 0.5 - view[0] * 1.5,
+                    at[1] + height * y - view[1] * 1.5,
+                    at[2] + width * (2.0 * z - 1.0) * 0.5 - view[2] * 1.5,
+                ];
+                self.particles.add(&bubble, p, [0.0; 3]);
+            }
+        }
+        for (eye, target, scale) in beams {
+            let d = [target[0] - eye[0], target[1] - eye[1], target[2] - eye[2]];
+            let length = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt();
+            if length <= 0.0 {
+                continue;
+            }
+            let mut dist = self.particles.random().next_double();
+            while dist < length {
+                let r = self.particles.random();
+                dist += 1.8 - scale + r.next_double() * (1.7 - scale);
+                let f = dist / length;
+                let p = [eye[0] + d[0] * f, eye[1] + d[1] * f, eye[2] + d[2] * f];
+                self.particles.add(&bubble, p, [0.0; 3]);
+            }
+        }
+    }
     /// Mob models and projectiles for the entity pass.
     pub(super) fn mob_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec<Vertex>) {
         let atlas = &self.gui.atlas;
         let lookup = |name: &str| atlas.sprites.get(name).map(|r| [r.u0, r.v0, r.u1, r.v1]);
-        let scale = f64::from(self.settings.entity_distance);
+        let scale = self.view_scale();
         for mob in &self.mobs {
             let entity_start = out.len();
-            // Entity.DATA_SHARED_FLAGS_ID invisible: only the name tag draws.
-            if mob.invisible {
+            let outline = self.mob_outline(mob);
+            // Entity.DATA_SHARED_FLAGS_ID invisible: only the name tag draws (and
+            // the outline of a glowing mob, LivingEntityRenderer.getRenderType).
+            if mob.invisible && outline.is_none() {
                 continue;
             }
             let d = glam::DVec3::new(mob.position.x, mob.position.y, mob.position.z) - camera;
             // Entity.shouldRenderAtSqrDistance: 64 times the bounding box's
-            // mean edge, scaled by the entity distance option.
+            // mean edge, scaled by the view scale. RemotePlayer's box counts
+            // ten times.
             let (w, h, _) = mob.dims();
-            let range = (w + h + w) / 3.0 * 64.0 * scale;
+            let edge = (w + h + w) / 3.0
+                * if &*mob.kind.id == "minecraft:player" {
+                    10.0
+                } else {
+                    1.0
+                };
+            let range = edge * 64.0 * scale;
             if d.length_squared() >= range * range {
                 continue;
             }
@@ -3101,9 +3863,18 @@ impl Game<'_> {
                 out,
             );
             self.mob_block_geometry(mob, camera, alpha, packed, out);
+            if let Some(rgb) = outline {
+                self.mark_outline(&out[entity_start..], rgb);
+                if mob.invisible {
+                    out.truncate(entity_start);
+                    continue;
+                }
+            }
             // Glowing outlines and a guardian's beam remain visible independently
             // of whether the body is hidden behind terrain.
-            if !mob.glowing && horizon_client::mobs::guardian::beam(mob, alpha as f32).is_none() {
+            if outline.is_none()
+                && horizon_client::mobs::guardian::beam(mob, alpha as f32).is_none()
+            {
                 self.cull_entity_vertices(out, entity_start);
             }
             // GuardianRenderer: the laser to the locked target.
@@ -3151,7 +3922,15 @@ impl Game<'_> {
             super::pickups::Taken::Arrow(a) => Some((&**a, super::pickups::position(p, alpha))),
             _ => None,
         });
+        // A glowing projectile's outline: what it drew up to the next one.
+        let mut glowing = None;
         for (a, at) in live.chain(taken) {
+            if let Some((start, rgb)) = glowing.take() {
+                self.mark_outline(&out[start..], rgb);
+            }
+            if a.id != 0 && self.entity_glowing(a.id) {
+                glowing = Some((out.len(), super::glowing::team_color(self.mob_team(a.id))));
+            }
             let p = glam::DVec3::from_array(at) - camera;
             let c = p.as_vec3();
             let light = self.world.light(
@@ -3187,6 +3966,30 @@ impl Game<'_> {
                 }
                 continue;
             }
+            // ThrownTridentRenderer.
+            if matches!(a.kind, ProjectileKind::Trident) {
+                let Some(model) = self.trident_model.as_ref() else {
+                    continue;
+                };
+                let Some(r) = atlas.sprites.get("entity/trident/trident").copied() else {
+                    continue;
+                };
+                let m = glam::Mat4::from_translation(c)
+                    * glam::Mat4::from_rotation_y((a.yaw - 90.0).to_radians())
+                    * glam::Mat4::from_rotation_z((a.pitch + 90.0).to_radians());
+                let poses = horizon_client::mobs::anim::Poses::new(model);
+                horizon_client::mobs::render::draw(
+                    model,
+                    m,
+                    &poses,
+                    [r.u0, r.v0, r.u1, r.v1],
+                    0xFFFF_FFFF,
+                    packed,
+                    0,
+                    out,
+                );
+                continue;
+            }
             // WindChargeRenderer.
             if matches!(
                 a.kind,
@@ -3256,11 +4059,36 @@ impl Game<'_> {
                     layer: 0,
                     color: 0xFFFF_FFFF,
                     light: packed,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
+        if let Some((start, rgb)) = glowing {
+            self.mark_outline(&out[start..], rgb);
+        }
     }
 }
+/// `Bucketable.getBucketItemStack` and `getPickupSound` of a mob that a water
+/// bucket picks up.
+fn bucketable(species: Species) -> Option<(&'static str, &'static str)> {
+    let fish = "minecraft:item.bucket.fill_fish";
+    Some(match species {
+        Species::Cod => ("minecraft:cod_bucket", fish),
+        Species::Salmon => ("minecraft:salmon_bucket", fish),
+        Species::Pufferfish => ("minecraft:pufferfish_bucket", fish),
+        Species::TropicalFish => ("minecraft:tropical_fish_bucket", fish),
+        Species::Tadpole => (
+            "minecraft:tadpole_bucket",
+            "minecraft:item.bucket.fill_tadpole",
+        ),
+        Species::Axolotl => (
+            "minecraft:axolotl_bucket",
+            "minecraft:item.bucket.fill_axolotl",
+        ),
+        _ => return None,
+    })
+}
 /// Mob.getBaseExperienceReward
 /// The damage type id of a Horizon damage kind.
 pub(super) fn damage_type(kind: horizon_client::mobs::DamageKind, player: bool) -> &'static str {
@@ -3280,6 +4108,7 @@ pub(super) fn damage_type(kind: horizon_client::mobs::DamageKind, player: bool)
         K::InFire => "minecraft:in_fire",
         K::Lava => "minecraft:lava",
         K::Drown => "minecraft:drown",
+        K::DryOut => "minecraft:dry_out",
         K::Magic => "minecraft:magic",
         K::Sting => "minecraft:sting",
         K::Cactus => "minecraft:cactus",
@@ -3287,6 +4116,7 @@ pub(super) fn damage_type(kind: horizon_client::mobs::DamageKind, player: bool)
         K::InWall => "minecraft:in_wall",
         K::Thorns => "minecraft:thorns",
         K::SonicBoom => "minecraft:sonic_boom",
+        K::Freeze => "minecraft:freeze",
         K::OutOfWorld => "minecraft:out_of_world",
     }
 }
@@ -3305,6 +4135,7 @@ fn to_loot(stack: &ItemStack) -> horizon_world::loot::LootStack {
         map: false,
         exploration: None,
         ominous_amplifier: None,
+        stew_effects: Vec::new(),
     }
 }
 /// A generated loot stack as a Horizon item stack.
diff --git a/crates/horizon-client/src/game/crossbow.rs b/crates/horizon-client/src/game/crossbow.rs
index 70ccba8d3..d66610183 100644
--- a/crates/horizon-client/src/game/crossbow.rs
+++ b/crates/horizon-client/src/game/crossbow.rs
@@ -6,6 +6,7 @@
 //! finds the ammo for bows and crossbows.
 use super::{Game, shield::OFFHAND_SLOT, view_vector};
 use horizon_client::{
+    enchant::EffectContext,
     items::ItemStack,
     mobs::Who,
     projectiles::{Projectile, ProjectileKind},
@@ -152,6 +153,20 @@ impl Game<'_> {
         };
         let charged = std::mem::take(&mut bow.data_mut().charged);
         bow.tidy();
+        let weapon = bow.clone();
+        // AbstractArrow's constructor: `getPiercingCount` of the weapon.
+        let pierce = self
+            .res
+            .stations()
+            .enchantments
+            .modify_value(
+                Some(&weapon),
+                "minecraft:projectile_piercing",
+                &EffectContext::default(),
+                &mut self.world.random,
+                0.0,
+            )
+            .clamp(0.0, 127.0) as u8;
         let count = charged.len();
         // getShootingPower: a rocket among them slows every shot.
         let power = if charged.iter().any(|s| &*s.item == FIREWORK_ROCKET) {
@@ -204,9 +219,10 @@ impl Game<'_> {
                 if let Some(a) = arrow.arrow.as_mut() {
                     a.set_item(ammo);
                     a.set_owner(Some(Who::Player));
+                    a.pierce = pierce;
                 }
                 arrow.shoot(&mut self.world.random, dir.to_array(), power, 1.0);
-                self.creatures.projectiles.push(arrow);
+                self.add_projectile(arrow);
             }
             self.player_projectile_shot();
             let pitch = if index == 0 {
diff --git a/crates/horizon-client/src/game/cushions.rs b/crates/horizon-client/src/game/cushions.rs
index 0847321d6..989009d82 100644
--- a/crates/horizon-client/src/game/cushions.rs
+++ b/crates/horizon-client/src/game/cushions.rs
@@ -348,11 +348,15 @@ impl Game<'_> {
         let Some(state) = self.pack.assets.registry.default_state(&name) else {
             return;
         };
-        let at = [
-            c.position.x.floor() as i32,
-            c.position.y.floor() as i32,
-            c.position.z.floor() as i32,
-        ];
+        let p = c.position;
+        // Entity.getY(2/3) is relative to the cushion's quarter-block height.
+        let particle_at = [p.x, p.y + 0.25 * (2.0 / 3.0), p.z];
+        // Guest actions temporarily take self.lan; flush once the hub is back.
+        // Queue before resolving a sprite: a dedicated server has no renderer.
+        if self.audio.capture.is_some() {
+            self.lan_cushion_breaks.push((state, particle_at));
+        }
+        let at = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32];
         let Some((sprite, tint)) = self.particle_sprite(state, at) else {
             return;
         };
@@ -361,14 +365,8 @@ impl Game<'_> {
             sprite,
             tint,
         );
-        let p = c.position;
-        self.particles.send_particles(
-            &options,
-            [p.x, p.y + 0.666_666_7, p.z],
-            [0.25, 0.0625, 0.25],
-            0.05,
-            10,
-        );
+        self.particles
+            .send_particles(&options, particle_at, [0.25, 0.0625, 0.25], 0.05, 10);
     }
 
     /// `BlockAttachedEntity.tick`: survive and burn checks after the post-increment reaches 100.
@@ -455,8 +453,7 @@ impl Game<'_> {
                 glam::DVec3::new(lo.x, lo.y, lo.z),
                 glam::DVec3::new(hi.x, hi.y, hi.z),
             );
-            let range =
-                super::entity_culling::default_range(hi - lo, self.settings.entity_distance);
+            let range = super::entity_culling::default_range(hi - lo, self.view_scale());
             if !self.entity_in_view(camera, (lo + hi) / 2.0, range, lo, hi) {
                 continue;
             }
diff --git a/crates/horizon-client/src/game/debug_keys.rs b/crates/horizon-client/src/game/debug_keys.rs
index 16e7fc6e7..dc79bf8c1 100644
--- a/crates/horizon-client/src/game/debug_keys.rs
+++ b/crates/horizon-client/src/game/debug_keys.rs
@@ -13,7 +13,7 @@ use horizon_client::{
     save::VERSION_NAME,
     text::Text,
 };
-use horizon_core::geometry::Axis;
+use horizon_core::geometry::{Axis, Vec3};
 use winit::keyboard::KeyCode;
 
 /// `ChatFormatting.YELLOW` and `RED`.
@@ -766,7 +766,8 @@ impl Game<'_> {
         }
         let lerp = |a: f64, b: f64| a + f64::from(alpha) * (b - a);
         let lerpf = |a: f32, b: f32| a + alpha * (b - a);
-        for m in &self.mobs {
+        let guests = self.lan.iter().flat_map(|h| h.models.values());
+        for m in self.mobs.iter().chain(guests) {
             if m.removed || m.invisible || m.has_effect("minecraft:invisibility") {
                 continue;
             }
@@ -796,6 +797,159 @@ impl Game<'_> {
             // EntityType.ITEM: 0.25 by 0.25, eyes at 0.2125.
             g.hitbox(pos, (0.25, 0.25), 0.2125, false, (0.0, 0.0));
         }
+        // The other entities (EntityTypes sizes; eyes at 0.85 of the height
+        // unless the type sets one). `at` is the interpolated position.
+        let at = |previous: Vec3, now: Vec3| {
+            [
+                lerp(previous.x, now.x),
+                lerp(previous.y, now.y),
+                lerp(previous.z, now.z),
+            ]
+        };
+        for p in &self.paintings {
+            let (min, max) = p.bounds();
+            let centre = std::array::from_fn(|i| (min[i] + max[i]) / 2.0);
+            g.entity_box(min, max, centre, 0.425, false, step_view(p.step()));
+        }
+        for f in self.item_frames.iter().filter(|f| !f.invisible) {
+            let (min, max) = f.bounds();
+            let centre = std::array::from_fn(|i| (min[i] + max[i]) / 2.0);
+            g.entity_box(min, max, centre, 0.0, false, step_view(f.step()));
+        }
+        for c in &self.cushions {
+            let (min, max) = c.bounds();
+            let p = c.position;
+            g.entity_box(min, max, [p.x, p.y, p.z], 0.2125, false, (0.0, c.yaw));
+        }
+        for a in self.armor_stands.iter().filter(|a| !a.invisible) {
+            // ArmorStand.getDimensions: a marker has none, a small one is
+            // half scale with its eyes at 0.9875.
+            let (size, eye) = match (a.marker, a.small) {
+                (true, _) => ((0.0, 0.0), 0.0),
+                (_, true) => ((0.25, 0.9875), 0.9875),
+                _ => ((0.5, 1.975), 1.7775),
+            };
+            let p = a.position;
+            g.hitbox([p.x, p.y, p.z], size, eye, true, (0.0, a.yaw));
+        }
+        for b in &self.boats {
+            let h = super::boats::HEIGHT as f32;
+            g.hitbox(
+                at(b.previous, b.position),
+                (super::boats::WIDTH as f32, h),
+                h,
+                false,
+                (0.0, b.yaw),
+            );
+        }
+        for c in &self.carts {
+            let (w, h) = (
+                super::minecarts::WIDTH as f32,
+                super::minecarts::HEIGHT as f32,
+            );
+            g.hitbox(
+                at(c.previous, c.position),
+                (w, h),
+                h * 0.85,
+                false,
+                (0.0, c.yaw),
+            );
+        }
+        for o in &self.orbs {
+            g.hitbox(
+                at(o.previous, o.position),
+                (0.5, 0.5),
+                0.425,
+                false,
+                (0.0, 0.0),
+            );
+        }
+        for f in &self.falling {
+            g.hitbox(
+                at(f.previous, f.position),
+                (0.98, 0.98),
+                0.833,
+                false,
+                (0.0, 0.0),
+            );
+        }
+        for t in &self.tnts {
+            g.hitbox(
+                at(t.previous, t.position),
+                (0.98, 0.98),
+                0.15,
+                false,
+                (0.0, 0.0),
+            );
+        }
+        for c in &self.crystals {
+            let p = c.position;
+            g.hitbox([p.x, p.y, p.z], (2.0, 2.0), 1.7, false, (0.0, 0.0));
+        }
+        for p in &self.creatures.projectiles {
+            use horizon_client::projectiles::ProjectileKind as K;
+            let (size, eye) = match p.kind {
+                K::Arrow { .. } | K::Trident => (0.5, 0.13),
+                K::Snowball | K::Egg | K::EnderPearl | K::LlamaSpit | K::Potion { .. } => {
+                    (0.25, 0.2125)
+                }
+                K::SmallFireball | K::ShulkerBullet { .. } | K::WitherSkull { .. } => {
+                    (0.3125, 0.265_625)
+                }
+                K::WindCharge | K::BreezeWindCharge => (0.3125, 0.0),
+                K::LargeFireball { .. } => (1.0, 0.85),
+            };
+            g.hitbox(
+                at(p.previous, p.position),
+                (size, size),
+                eye,
+                false,
+                (p.pitch, p.yaw),
+            );
+        }
+        for t in &self.tridents {
+            g.hitbox(
+                at(t.previous, t.position),
+                (0.5, 0.5),
+                0.13,
+                false,
+                (t.pitch, t.yaw),
+            );
+        }
+        for r in &self.rockets {
+            // Projectile.updateRotation: the look follows the motion.
+            let v = r.velocity;
+            let yaw = v.x.atan2(v.z).to_degrees() as f32;
+            let pitch = v.y.atan2(v.x.hypot(v.z)).to_degrees() as f32;
+            g.hitbox(
+                at(r.previous, r.position),
+                (0.25, 0.25),
+                0.2125,
+                false,
+                (pitch, yaw),
+            );
+        }
+        for h in self
+            .hook
+            .iter()
+            .map(|h| (h.previous, h.position))
+            .chain(self.remote_hooks.iter().map(|h| (h.previous, h.position)))
+        {
+            g.hitbox(at(h.0, h.1), (0.25, 0.25), 0.2125, false, (0.0, 0.0));
+        }
+        for b in &self.bolts {
+            g.hitbox(b.at, (0.0, 0.0), 0.0, false, (0.0, 0.0));
+        }
+        // The dragon: 16 by 8, a living entity; its parts follow.
+        if let Some(d) = &self.dragon {
+            g.hitbox(
+                at(d.previous, d.position),
+                (16.0, 8.0),
+                6.8,
+                true,
+                (0.0, d.yaw),
+            );
+        }
         // The dragon's parts.
         for (id, b) in self.special_targets() {
             if (super::dragon::SPECIAL..super::dragon::SPECIAL + 8).contains(&id) {
@@ -828,3 +982,12 @@ impl Game<'_> {
         g
     }
 }
+
+/// The (x, y) rotations whose view vector is the step of a direction.
+fn step_view(step: [i32; 3]) -> (f32, f32) {
+    let [x, y, z] = step.map(f64::from);
+    (
+        (-y).asin().to_degrees() as f32,
+        (-x.atan2(z)).to_degrees() as f32,
+    )
+}
diff --git a/crates/horizon-client/src/game/dedicated.rs b/crates/horizon-client/src/game/dedicated.rs
index fa5365195..73c6fd4cc 100644
--- a/crates/horizon-client/src/game/dedicated.rs
+++ b/crates/horizon-client/src/game/dedicated.rs
@@ -24,6 +24,7 @@ use horizon_client::{
 use horizon_protocol::text::translatable;
 use horizon_world::nbt::{JavaString, Tag};
 use std::{
+    io::Write,
     path::PathBuf,
     sync::{Arc, Mutex, OnceLock, mpsc},
     time::{Duration, Instant},
@@ -89,7 +90,9 @@ fn log_from(thread: &str, level: &str, message: &str) {
         }
     });
     // Log4j's %d{HH:mm:ss}: the local time, as in logs/latest.log.
-    println!(
+    // The launcher can close its stdout pipe while the server keeps running.
+    let _ = writeln!(
+        std::io::stdout().lock(),
         "[{}] [{thread}/{level}]: {message}",
         chrono::Local::now().format("%H:%M:%S")
     );
@@ -618,6 +621,22 @@ impl Game<'_> {
                 log_ips: props.log_ips,
             }),
             resource_pack: props.resource_pack.clone(),
+            // DedicatedServer.serverLinks: `bug-report-link` as the only link
+            // (ServerLinks.KnownLinkType.BUG_REPORT is id 0).
+            server_links: if props.bug_report_link.is_empty() {
+                Vec::new()
+            } else if super::server_links::valid_untrusted_uri(&props.bug_report_link) {
+                vec![horizon_protocol::packets::configuration::ServerLink {
+                    kind: horizon_protocol::packets::configuration::ServerLinkKind::Known(0),
+                    link: props.bug_report_link.clone(),
+                }]
+            } else {
+                log(
+                    "WARN",
+                    &format!("Failed to parse bug link {}", props.bug_report_link),
+                );
+                Vec::new()
+            },
         };
         let config = HubConfig {
             default_game_mode: game_mode,
@@ -654,6 +673,9 @@ impl Game<'_> {
         // DedicatedServer.initServer ends with saveEverything(false, true, true).
         self.save_game()?;
         self.log_saved_levels();
+        if let Some(host) = self.lan.as_mut() {
+            host.hub.entity_range_percent = props.entity_broadcast_range_percentage;
+        }
         let mut state = ServerState {
             lists,
             console,
@@ -1308,3 +1330,110 @@ fn png_size(bytes: &[u8]) -> Option<(u32, u32)> {
     let h = u32::from_be_bytes(bytes[20..24].try_into().ok()?);
     Some((w, h))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{capture_log, log, log_from};
+    use std::{
+        fs,
+        io::{self, BufRead, BufReader, Read, Write},
+        process::{Command, Stdio},
+        time::{SystemTime, UNIX_EPOCH},
+    };
+
+    const LOGIN: &str = "Player[/127.0.0.1:0] logged in with entity id 2 at (0.5, 115.0, 0.5)";
+    const WARNING: &str = "Authentication warning";
+    const READY: &str = "horizon-console-log-ready\n";
+    const CHILD_HOME: &str = "HORIZON_TEST_CONSOLE_LOG_HOME";
+
+    fn assert_log_lines(text: &str) {
+        let expected = [
+            format!("] [Server thread/INFO]: {LOGIN}"),
+            format!("] [User Authenticator #1/WARN]: {WARNING}"),
+        ];
+        assert_eq!(text.lines().count(), expected.len());
+        for (line, suffix) in text.lines().zip(expected) {
+            assert!(line.starts_with('['));
+            assert!(chrono::NaiveTime::parse_from_str(&line[1..9], "%H:%M:%S").is_ok());
+            assert_eq!(&line[9..], suffix);
+        }
+    }
+
+    #[test]
+    fn console_logging_survives_closed_stdout() {
+        if let Some(home) = std::env::var_os(CHILD_HOME) {
+            horizon_client::logging::init(std::path::Path::new(&home), "Server thread");
+            // Let the parent close the real stdout pipe only after libtest's startup output.
+            io::stdout().write_all(READY.as_bytes()).unwrap();
+            io::stdout().flush().unwrap();
+            io::stdin().read_exact(&mut [0]).unwrap();
+            std::thread::Builder::new()
+                .name("Server thread".into())
+                .spawn(|| {
+                    let captured = capture_log(|| {
+                        log("INFO", LOGIN);
+                        log_from("User Authenticator #1", "WARN", WARNING);
+                    });
+                    assert_eq!(captured, [LOGIN, WARNING]);
+                    horizon_client::logging::flush();
+                })
+                .unwrap()
+                .join()
+                .unwrap();
+            // Libtest's final status also writes to stdout; only the game logger is under test.
+            std::process::exit(0);
+        }
+
+        for closed_stdout in [false, true] {
+            let unique = SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .unwrap()
+                .as_nanos();
+            let home = std::env::temp_dir().join(format!(
+                "horizon-console-log-test-{}-{unique}",
+                std::process::id()
+            ));
+            fs::create_dir(&home).unwrap();
+            let mut child = Command::new(std::env::current_exe().unwrap())
+                .args([
+                    "--exact",
+                    "game::dedicated::tests::console_logging_survives_closed_stdout",
+                    "--nocapture",
+                ])
+                .env(CHILD_HOME, &home)
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped())
+                .spawn()
+                .unwrap();
+            let mut stdout = BufReader::new(child.stdout.take().unwrap());
+            loop {
+                let mut line = String::new();
+                assert!(
+                    stdout.read_line(&mut line).unwrap() > 0,
+                    "child was not ready"
+                );
+                if line.ends_with(READY) {
+                    break;
+                }
+            }
+            if closed_stdout {
+                drop(stdout); // No reader remains: the next console write gets EPIPE.
+            } else {
+                child.stdout = Some(stdout.into_inner());
+            }
+            child.stdin.take().unwrap().write_all(&[1]).unwrap();
+            let output = child.wait_with_output().unwrap();
+            assert!(
+                output.status.success(),
+                "closed_stdout={closed_stdout}: {}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+            if !closed_stdout {
+                assert_log_lines(std::str::from_utf8(&output.stdout).unwrap());
+            }
+            assert_log_lines(&fs::read_to_string(home.join("logs/latest.log")).unwrap());
+            fs::remove_dir_all(home).unwrap();
+        }
+    }
+}
diff --git a/crates/horizon-client/src/game/deflect.rs b/crates/horizon-client/src/game/deflect.rs
index a08de87b3..088374a34 100644
--- a/crates/horizon-client/src/game/deflect.rs
+++ b/crates/horizon-client/src/game/deflect.rs
@@ -120,6 +120,11 @@ impl Game<'_> {
         p.guest = guest;
         // Not into the one who turned it on its way out.
         p.left_owner = false;
+        // `AbstractHurtingProjectile.onDeflection` by an attack, and the
+        // `needsSync` that `AIM_DEFLECT` sets: a server's players see it turn
+        // at once, not at the fireball's next update ten ticks later.
+        p.acceleration = 0.1;
+        p.needs_sync = true;
         self.reset_attack_strength();
         self.swing_arm();
         let from = self
diff --git a/crates/horizon-client/src/game/dispense_fixture.rs b/crates/horizon-client/src/game/dispense_fixture.rs
index 267f323c3..33da8b5ce 100644
--- a/crates/horizon-client/src/game/dispense_fixture.rs
+++ b/crates/horizon-client/src/game/dispense_fixture.rs
@@ -725,6 +725,11 @@ impl Game<'_> {
         match self.world.block_entities.get_mut(&p) {
             Some(BlockEntity::Jukebox(j)) => j.record = stack,
             Some(BlockEntity::Lectern(l)) => l.book = stack,
+            Some(BlockEntity::Campfire(c)) => {
+                if let Some(cell) = c.items.get_mut(slot) {
+                    *cell = stack;
+                }
+            }
             Some(e) => {
                 if let Some(cell) = e.slots_mut().get_mut(slot) {
                     *cell = stack;
@@ -1126,14 +1131,18 @@ impl Game<'_> {
             let (p, v) = (b.position, b.velocity);
             out.push(line(&kind, [p.x, p.y, p.z], [v.x, v.y, v.z], ""));
         }
+        // A merged orb prints once per count, as the oracle does: whether orbs
+        // merge depends on entity ids, which differ from vanilla's.
         for o in &self.orbs {
             let (p, v) = (o.position, o.velocity);
-            out.push(line(
-                "minecraft:experience_orb",
-                [p.x, p.y, p.z],
-                [v.x, v.y, v.z],
-                "",
-            ));
+            for _ in 0..o.count.max(1) {
+                out.push(line(
+                    "minecraft:experience_orb",
+                    [p.x, p.y, p.z],
+                    [v.x, v.y, v.z],
+                    "",
+                ));
+            }
         }
         for c in &self.carts {
             let (p, v) = (c.position, c.velocity);
diff --git a/crates/horizon-client/src/game/dispenser.rs b/crates/horizon-client/src/game/dispenser.rs
index 61725c6ab..a0a9bfd93 100644
--- a/crates/horizon-client/src/game/dispenser.rs
+++ b/crates/horizon-client/src/game/dispenser.rs
@@ -982,7 +982,7 @@ impl Game<'_> {
             | "minecraft:lingering_potion" => {
                 let mut shot = Projectile::new(ProjectileKind::Snowball, at, None);
                 shot.shoot(&mut own, dir, power, uncertainty);
-                self.launch_thrown(one, at, shot.velocity);
+                self.launch_thrown(one, at, shot.velocity, None);
             }
             "minecraft:firework_rocket" => {
                 let mut shot = Projectile::new(ProjectileKind::Snowball, at, None);
@@ -1034,7 +1034,7 @@ impl Game<'_> {
                     a.pickup = horizon_client::arrows::Pickup::Allowed;
                 }
                 shot.shoot(&mut own, dir, power, uncertainty);
-                self.creatures.projectiles.push(shot);
+                self.add_projectile(shot);
             }
         }
     }
diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs
index fff03ef1c..250887b30 100644
--- a/crates/horizon-client/src/game/dragon.rs
+++ b/crates/horizon-client/src/game/dragon.rs
@@ -27,6 +27,8 @@ pub(super) const SPECIAL: u32 = u32::MAX - 4096;
 const CRYSTAL_IDS: u32 = SPECIAL + 16;
 const FIGHT_FILE: &str = "data/minecraft/ender_dragon_fight.dat";
 const MAX_HEALTH: f32 = 200.0;
+/// `Mob.getAmbientSoundInterval`.
+const AMBIENT_INTERVAL: i32 = 80;
 
 #[derive(Default)]
 pub(super) struct Fight {
@@ -48,6 +50,9 @@ pub(super) struct Fight {
     respawn: Option<(Respawn, i32)>,
     /// The four crystals on the exit portal driving the respawn.
     respawn_crystals: Vec<Vec3>,
+    /// The player behind the crystal blast under way, whose `explosion`
+    /// damage source names them (`EndCrystal.hurtServer`).
+    blast_by: Option<FightWho>,
     dirty: bool,
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -262,6 +267,9 @@ pub(super) struct Dragon {
     /// only damage above the last hit lands, and only the excess.
     invulnerable: i32,
     last_hurt: f32,
+    /// `lastHurtByPlayer` with its 100 tick memory: the player credited with
+    /// the kill, and the dragon tick of their last hit.
+    hurt_by_player: Option<(FightWho, i32)>,
     pub death_time: i32,
     pub flap: f32,
     pub old_flap: f32,
@@ -270,6 +278,8 @@ pub(super) struct Dragon {
     flame_count: i32,
     sitting_damage: f32,
     growl: i32,
+    /// `Mob.ambientSoundTime`.
+    ambient_time: i32,
     ticks: i32,
     /// DragonFlightHistory: (y, yRot) samples, newest at `head`.
     history: [(f64, f32); 64],
@@ -291,11 +301,11 @@ pub(super) enum FightWho {
 }
 /// A player in the End as the dragon sees it.
 #[derive(Clone, Copy, Debug)]
-struct FightPlayer {
-    who: FightWho,
-    position: Vec3,
-    bounds: Aabb,
-    alive: bool,
+pub(super) struct FightPlayer {
+    pub(super) who: FightWho,
+    pub(super) position: Vec3,
+    pub(super) bounds: Aabb,
+    pub(super) alive: bool,
     creative: bool,
     spectator: bool,
 }
@@ -385,6 +395,7 @@ impl Dragon {
             hurt_time: 0,
             invulnerable: 0,
             last_hurt: 0.0,
+            hurt_by_player: None,
             death_time: 0,
             flap: 0.0,
             old_flap: 0.0,
@@ -397,6 +408,7 @@ impl Dragon {
             flame_count: 0,
             sitting_damage: 0.0,
             growl: 100,
+            ambient_time: 0,
             ticks: 0,
             history: [(position.y, yaw); 64],
             head: 0,
@@ -426,6 +438,10 @@ impl Dragon {
     pub fn alive(&self) -> bool {
         self.health > 0.0
     }
+    /// `isDeadOrDying` for the killing blow: the dying flight, or no health.
+    fn down(&self) -> bool {
+        matches!(self.phase, Phase::Dying { .. }) || !self.alive()
+    }
     fn part_box(&self, i: usize) -> Aabb {
         let (w, h) = PART_SIZES[i];
         let p = self.parts[i].0;
@@ -693,7 +709,7 @@ impl Game<'_> {
     }
     /// The players in the level the dragon sees (`level.players()`): the
     /// window's own, then every guest in the level.
-    fn fight_players(&self) -> Vec<FightPlayer> {
+    pub(super) fn fight_players(&self) -> Vec<FightPlayer> {
         let mut out = Vec::new();
         if let Some(p) = self.player.as_ref() {
             out.push(FightPlayer {
@@ -722,7 +738,7 @@ impl Game<'_> {
     }
     /// Run `f` as the fight's player `who` (a guest's turn, its knockback
     /// sent to its client).
-    fn as_fight_player(&mut self, who: FightWho, f: impl FnOnce(&mut Self)) {
+    pub(super) fn as_fight_player(&mut self, who: FightWho, f: impl FnOnce(&mut Self)) {
         match who {
             FightWho::Host => f(self),
             FightWho::Guest(conn) => {
@@ -828,8 +844,10 @@ impl Game<'_> {
                 continue;
             }
             let time = self.world.random.next_int_bound(100_000).unwrap_or(0);
+            // EndCrystal's constructor takes an id from the entity counter.
+            self.next_entity += 1;
             self.crystals.push(Crystal {
-                id: 0,
+                id: self.next_entity,
                 position: at,
                 show_bottom: true,
                 time,
@@ -891,8 +909,12 @@ impl Game<'_> {
                 .any(|p| p.distance_squared(c.position) < 0.01);
         if damage == CrystalDamage::Direct {
             let at = [c.position.x, c.position.y, c.position.z];
+            // The blast's damage source carries the player, so the dragon
+            // remembers them before the blast can kill it.
+            self.fight.blast_by = by;
             let _ =
                 self.server_explode(at, 6.0, super::explosion::BlockInteraction::Destroy, false);
+            self.fight.blast_by = None;
         }
         if respawn_crystal {
             self.abort_respawn();
@@ -903,7 +925,7 @@ impl Game<'_> {
         if let Some(d) = self.dragon.as_mut() {
             if d.nearest_crystal == Some(index) {
                 d.nearest_crystal = None;
-                self.hurt_dragon(0, 10.0, true, false);
+                self.hurt_dragon(0, 10.0, true, by, false);
             } else if let Some(n) = d.nearest_crystal.as_mut()
                 && *n > index
             {
@@ -975,18 +997,46 @@ impl Game<'_> {
             self.destroy_crystal(index, by, CrystalDamage::Direct);
             Hurt::Landed { full: true }
         } else if id >= SPECIAL {
-            self.hurt_dragon((id - SPECIAL) as usize, amount, by_player, arrow)
+            let by = by_player.then(|| self.acting_player());
+            self.hurt_dragon((id - SPECIAL) as usize, amount, by_player, by, arrow)
         } else {
             Hurt::Refused
         }
     }
     /// `EnderDragon.hurt(part, source, damage)` on the dragon in the level.
-    fn hurt_dragon(&mut self, part: usize, damage: f32, counts: bool, arrow: bool) -> Hurt {
+    /// `by` is the player behind the hit, remembered for the kill credit.
+    fn hurt_dragon(
+        &mut self,
+        part: usize,
+        damage: f32,
+        counts: bool,
+        by: Option<FightWho>,
+        arrow: bool,
+    ) -> Hurt {
         let Some(d) = self.dragon.as_mut() else {
             return Hurt::Refused;
         };
+        let was_down = d.down();
+        let (cooldown, last_hurt) = (d.invulnerable, d.last_hurt);
         let hurt = d.hurt(part, damage, counts, arrow);
+        // LivingEntity.hurtServer: damage that is applied sets lastHurtByPlayer
+        // (100 ticks); a hit the damage cooldown absorbs returns before that.
+        if counts
+            && matches!(hurt, Hurt::Landed { .. })
+            && (d.invulnerable != cooldown || d.last_hurt != last_hurt)
+            && let Some(who) = by
+        {
+            d.hurt_by_player = Some((who, d.ticks));
+        }
+        if !was_down && d.down() {
+            self.credit_dragon_kill();
+        }
+        let Some(d) = self.dragon.as_mut() else {
+            return hurt;
+        };
         if hurt == (Hurt::Landed { full: true }) {
+            // Mob.playHurtSound: the ambient sound clock starts again.
+            d.ambient_time = -AMBIENT_INTERVAL;
             let at = [d.position.x, d.position.y, d.position.z];
             let pitch = 0.8 + self.world.random.next_float() * 0.3;
             self.audio
@@ -994,6 +1044,47 @@ impl Game<'_> {
         }
         hurt
     }
+    /// `LivingEntity.die`: `getKillCredit().awardKillScore`, for the player
+    /// who hurt the dragon within the last 100 ticks. A guest's kill is
+    /// theirs: their statistics, scores and advancements.
+    fn credit_dragon_kill(&mut self) {
+        let Some(d) = self.dragon.as_ref() else {
+            return;
+        };
+        let Some((who, _)) = d.hurt_by_player.filter(|(_, hit)| d.ticks - hit <= 100) else {
+            return;
+        };
+        let view = horizon_client::advancements::EntityView {
+            kind: "minecraft:ender_dragon".to_owned(),
+            position: [d.position.x, d.position.y, d.position.z],
+            ..Default::default()
+        };
+        let id = d.id;
+        let guest = match who {
+            FightWho::Guest(conn) if self.lan_acting.is_none() => Some(conn),
+            _ => None,
+        };
+        let credited = guest.is_some_and(|conn| {
+            let Some(mut host) = self.lan.take() else {
+                return false;
+            };
+            let done = self
+                .as_guest(&mut host, conn, |g| g.award_dragon_kill(id, &view))
+                .is_some();
+            self.lan = Some(host);
+            done
+        });
+        if !credited {
+            self.award_dragon_kill(id, &view);
+        }
+    }
+    /// `ServerPlayer.awardKillScore` for the dragon, on the killer's state.
+    fn award_dragon_kill(&mut self, id: u32, view: &horizon_client::advancements::EntityView) {
+        self.stats.add("killed", "minecraft:ender_dragon", 1);
+        self.stats.custom("mob_kills", 1);
+        self.score_player_killed(super::commands::Target::Mob(id));
+        self.trigger_entity("minecraft:player_killed_entity", "entity", view);
+    }
     /// Player melee on the dragon's parts or a crystal under the crosshair.
     /// The dragon part under the crosshair within reach: its id and distance.
     pub(super) fn dragon_hit(&self) -> Option<(u32, f64)> {
@@ -1566,6 +1657,7 @@ impl Game<'_> {
                         age: 0,
                         duration: 200,
                         from_dragon: true,
+                        potion: None,
                     });
                 }
             }
@@ -1658,6 +1750,24 @@ impl Game<'_> {
             self.tick_dragon_death();
             return;
         }
+        // Mob.baseTick: the ambient sound, rarer right after one.
+        let roll = d.random.next_int_bound(1000).unwrap_or(999);
+        let waited = d.ambient_time;
+        d.ambient_time += 1;
+        if roll < waited {
+            d.ambient_time = -AMBIENT_INTERVAL;
+            let at = [d.position.x, d.position.y, d.position.z];
+            // LivingEntity.getVoicePitch, from the dragon's own random.
+            let r = &mut d.random;
+            let pitch = (r.next_float() - r.next_float()) * 0.2 + 1.0;
+            self.audio.play(
+                "minecraft:entity.ender_dragon.ambient",
+                Some(at),
+                5.0,
+                pitch,
+            );
+        }
+        let d = self.dragon.as_mut().expect("dragon");
         // Flapping, growls and the flap sound.
         let flap_was = (d.old_flap * std::f32::consts::TAU).cos();
         let v = d.velocity;
@@ -2078,12 +2188,18 @@ impl Game<'_> {
                     age: 0,
                     duration: 600,
                     from_dragon: false,
+                    potion: None,
                 });
-                self.audio.play(
-                    "minecraft:entity.dragon_fireball.explode",
-                    Some([next.x, next.y, next.z]),
-                    1.0,
-                    1.0,
+                // DragonFireball.onHit: level event 2006 (the burst of dragon
+                // breath and the explosion sound) at its block position.
+                self.level_event_at(
+                    2006,
+                    [
+                        next.x.floor() as i32,
+                        next.y.floor() as i32,
+                        next.z.floor() as i32,
+                    ],
+                    1,
                 );
                 return false;
             }
@@ -2110,6 +2226,10 @@ impl Game<'_> {
         let mut harmed: Vec<(FightWho, f32)> = Vec::new();
         let mut clouds = std::mem::take(&mut self.breath_clouds);
         clouds.retain_mut(|c| {
+            // Lingering potions' clouds tick with the potions.
+            if c.potion.is_some() {
+                return true;
+            }
             c.age += 1;
             if c.age >= c.duration {
                 return false;
@@ -2127,10 +2247,12 @@ impl Game<'_> {
                     c.at[1],
                     c.at[2] + f64::from(a.sin() * d),
                 ];
-                self.particles.add(
+                self.particles.add_with(
                     &ParticleOptions::simple(ParticleType::DragonBreath),
                     at,
                     [0.0, 0.0, 0.0],
+                    false,
+                    true,
                 );
             }
             // AreaEffectCloud: after its 20-tick wait, every 20 ticks per entity.
@@ -2157,11 +2279,14 @@ impl Game<'_> {
     }
     /// Damage from the dragon, which is its causing entity
     /// (`DamageSources.mobAttack(dragon)`, `indirectMagic(cloud, dragon)`): the
-    /// death message names it.
+    /// death message names it, or the cloud once the dragon is gone.
     fn dragon_hurts_player(&mut self, damage_type: &str, amount: f32) {
         if let Some(id) = self.dragon.as_ref().map(|d| d.id) {
             let name = Text::translate("entity.minecraft.ender_dragon", &[]);
             self.note_named_attacker(damage_type, id, name);
+        } else if damage_type == "minecraft:indirect_magic" {
+            let name = Text::translate("entity.minecraft.area_effect_cloud", &[]);
+            self.note_direct_entity(damage_type, name);
         }
         self.hurt_player_by(damage_type, amount);
     }
@@ -2254,8 +2379,22 @@ pub(super) struct Breath {
     pub(super) at: [f64; 3],
     pub(super) radius: f32,
     pub(super) age: i32,
-    duration: i32,
-    from_dragon: bool,
+    pub(super) duration: i32,
+    pub(super) from_dragon: bool,
+    /// A lingering potion's cloud (`ThrownLingeringPotion`): what it applies.
+    pub(super) potion: Option<super::potions::PotionCloud>,
+}
+impl Breath {
+    /// `AreaEffectCloud.isWaiting`: before its wait time (20 ticks, 10 for a
+    /// lingering potion's).
+    pub(super) fn waiting(&self) -> bool {
+        self.age
+            < if self.potion.is_some() {
+                super::potions::LINGERING_WAIT
+            } else {
+                20
+            }
+    }
 }
 impl Game<'_> {
     /// `EnderDragonRenderer` and `EnderDragonModel.setupAnim`.
@@ -2482,6 +2621,8 @@ impl Game<'_> {
                         layer: 2,
                         color: c,
                         light: 0,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
@@ -2547,6 +2688,8 @@ impl Game<'_> {
                     layer: 6,
                     color: c,
                     light: wrap_light,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
             (last_sin, last_cos, last_u) = (sin, cos, uu);
@@ -2592,13 +2735,17 @@ impl Game<'_> {
                     layer: 0,
                     color: 0xFFFF_FFFF,
                     light: 240 | 240 << 8,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
     }
     pub(super) fn fight_ready(&mut self) -> bool {
         self.load_fight();
-        self.fight.loaded
+        // spawnExitPortal runs from scanState and the dragon's death, both
+        // only with players in the fight.
+        self.fight.loaded && self.fight.players
     }
     pub(super) fn exit_portal(&self) -> Option<[i32; 3]> {
         self.fight.exit_portal
@@ -2715,8 +2862,9 @@ impl Game<'_> {
             let (lo, hi) = (b.min_position(), b.max_position());
             self.seen_percent(center, [lo.x, lo.y, lo.z], [hi.x, hi.y, hi.z])
         });
+        let by = self.fight.blast_by;
         for (part, amount) in hits {
-            self.hurt_dragon(part, amount, true, false);
+            self.hurt_dragon(part, amount, true, by, false);
         }
     }
 }
@@ -2830,8 +2978,11 @@ impl Game<'_> {
             return false;
         }
         let time = self.world.random.next_int_bound(100_000).unwrap_or(0);
+        // EndCrystal's constructor takes an id from the entity counter, so
+        // the crystal is an entity a command can name (`@e[type=end_crystal]`).
+        self.next_entity += 1;
         self.crystals.push(Crystal {
-            id: 0,
+            id: self.next_entity,
             position: Vec3::new(x + 0.5, y, z + 0.5),
             show_bottom: false,
             time,
@@ -2848,6 +2999,21 @@ impl Game<'_> {
         self.swing_arm();
         true
     }
+    /// `EndCrystal.kill` (`/kill`): the crystal is removed, without a blast
+    /// (`Entity.kill` does not hurt it).
+    pub(super) fn kill_crystal(&mut self, id: u32) {
+        if let Some(i) = self.crystals.iter().position(|c| c.id == id) {
+            self.destroy_crystal(i, None, CrystalDamage::Explosion);
+        }
+    }
+    /// `EnderDragon.kill` (`/kill`): `Entity.kill` removes the entity, it
+    /// does not hurt it (the dragon flies its death flight when its health
+    /// runs out).
+    pub(super) fn kill_dragon(&mut self, id: u32) {
+        if self.dragon.as_ref().is_some_and(|d| d.id == id) {
+            self.dragon = None;
+        }
+    }
     /// Any entity touching `room` (`Level.getEntities(null, box)`).
     fn entity_in(&self, room: Aabb) -> bool {
         let touches = |lo: Vec3, hi: Vec3| {
diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs
index 7cdb3e526..5688a3226 100644
--- a/crates/horizon-client/src/game/enchant_effects.rs
+++ b/crates/horizon-client/src/game/enchant_effects.rs
@@ -3,10 +3,14 @@
 //! unbreaking (`minecraft:item_damage`), sharpness/smite/bane and power
 //! (`minecraft:damage`), knockback, fire aspect, infinity (`minecraft:ammo_use`),
 //! thorns (`minecraft:post_attack`), mending (`minecraft:repair_with_xp`) and
-//! the armor attribute effects (respiration, depth strider, ...).
+//! the armor attribute effects (respiration, depth strider, ...) and Soul
+//! Speed's `location_changed` and `tick` effects.
 use super::Game;
-use horizon_client::{enchant::EffectContext, items::ItemStack};
-use horizon_core::random::RandomSource;
+use horizon_client::{
+    enchant::{EffectContext, Enchantments, level_value},
+    items::ItemStack,
+};
+use horizon_core::{position::BlockPos, random::RandomSource};
 
 /// Where Mending found a damaged item (`EnchantedItemInUse.inSlot`).
 #[derive(Clone, Copy)]
@@ -153,8 +157,10 @@ impl Game<'_> {
             items: Some(self.res.items()),
             ..Default::default()
         };
-        // minecraft:post_attack ignite effects of the attacker's weapon (fire aspect).
+        // minecraft:post_attack effects of the attacker's weapon on the victim:
+        // ignite (fire aspect) and apply_mob_effect (bane of arthropods).
         let mut ignite = 0.0f32;
+        let mut mob_effects = Vec::new();
         for (id, level) in held.enchantments() {
             let Some(def) = self.res.stations().enchantments.get(id) else {
                 continue;
@@ -164,24 +170,33 @@ impl Game<'_> {
                 .into_iter()
                 .flatten()
             {
-                if effect["enchanted"] == "attacker"
-                    && effect["affected"] == "victim"
-                    && effect["effect"]["type"] == "minecraft:ignite"
+                let e = &effect["effect"];
+                let kind_of = e["type"].as_str();
+                if effect["enchanted"] != "attacker"
+                    || effect["affected"] != "victim"
+                    || !matches!(
+                        kind_of,
+                        Some("minecraft:ignite" | "minecraft:apply_mob_effect")
+                    )
                 {
-                    let mut random = self.world.random.clone();
-                    let ok = effect.get("requirements").is_none_or(|r| {
-                        self.res
-                            .stations()
-                            .enchantments
-                            .condition(r, *level, &ctx, &mut random)
-                    });
-                    self.world.random = random;
-                    if ok {
-                        ignite = ignite.max(horizon_client::enchant::level_value(
-                            &effect["effect"]["duration"],
-                            *level,
-                        ));
-                    }
+                    continue;
+                }
+                let mut random = self.world.random.clone();
+                let ok = effect.get("requirements").is_none_or(|r| {
+                    self.res
+                        .stations()
+                        .enchantments
+                        .condition(r, *level, &ctx, &mut random)
+                });
+                self.world.random = random;
+                if !ok {
+                    continue;
+                }
+                if kind_of == Some("minecraft:ignite") {
+                    ignite =
+                        ignite.max(horizon_client::enchant::level_value(&e["duration"], *level));
+                } else {
+                    mob_effects.push((e.clone(), *level));
                 }
             }
         }
@@ -191,8 +206,41 @@ impl Game<'_> {
         {
             m.ignite_for_ticks((ignite * 20.0) as i32);
         }
+        for (effect, level) in mob_effects {
+            self.apply_mob_effect(mob, &effect, level);
+        }
         self.post_attack_bursts(&held, &kind);
     }
+    /// `ApplyMobEffect.apply`: one of `to_apply` (a single id or a list) for a
+    /// random duration and amplifier between the level-based bounds.
+    fn apply_mob_effect(&mut self, mob: usize, effect: &serde_json::Value, level: u32) {
+        use horizon_client::enchant::level_value;
+        let Some(m) = self.mobs.get_mut(mob) else {
+            return;
+        };
+        let ids: Vec<&str> = match &effect["to_apply"] {
+            serde_json::Value::String(id) => vec![id.as_str()],
+            serde_json::Value::Array(list) => list.iter().filter_map(|v| v.as_str()).collect(),
+            _ => Vec::new(),
+        };
+        if ids.is_empty() {
+            return;
+        }
+        // HolderSet.getRandomElement, then Mth.randomBetween for both values.
+        let pick = m.random.next_int_bound(ids.len() as i32).unwrap_or(0) as usize;
+        let mut between = |min: &str, max: &str| {
+            let (lo, hi) = (
+                level_value(&effect[min], level),
+                level_value(&effect[max], level),
+            );
+            m.random.next_float() * (hi - lo) + lo
+        };
+        let ticks = (between("min_duration", "max_duration") * 20.0).round() as i32;
+        let amplifier = (between("min_amplifier", "max_amplifier").round() as i32).max(0);
+        if let Some(id) = super::potions::mob_effect_id(ids[pick]) {
+            m.add_effect(id, ticks, amplifier);
+        }
+    }
     /// `minecraft:post_attack` explode effects on the attacker (wind burst):
     /// a burst at the player's feet that only knocks back and triggers
     /// blocks (`ExplodeEffect` with `block_interaction: trigger`).
@@ -303,8 +351,10 @@ impl Game<'_> {
                 continue;
             }
             hits.push(1.0 + self.world.random.next_float() * 4.0);
+            // ChangeItemDamage -> ItemStack.hurtAndBreak: unbreaking applies.
+            let loss = self.durability_loss(&stack, 2);
             if let Some(s) = self.armor[slot].as_mut() {
-                s.damage += 2;
+                s.damage += loss;
                 if self
                     .res
                     .items()
@@ -384,7 +434,9 @@ impl Game<'_> {
         }
     }
     /// Bow enchantments at release: (extra base damage, infinity keeps the arrow).
-    pub(super) fn bow_enchantments(&mut self) -> (f64, bool) {
+    /// `ammo` is the item being fired: `Enchantment.itemContext` hands it to the
+    /// `ammo_use` conditions as the tool, so Infinity only frees plain arrows.
+    pub(super) fn bow_enchantments(&mut self, ammo: &str) -> (f64, bool) {
         let Some(bow) = self.inventory[self.selected].clone() else {
             return (0.0, false);
         };
@@ -403,7 +455,7 @@ impl Game<'_> {
             0.0,
         );
         let ammo_ctx = EffectContext {
-            tool: Some("minecraft:arrow"),
+            tool: Some(ammo),
             items: Some(self.res.items()),
             ..Default::default()
         };
@@ -456,6 +508,134 @@ impl Game<'_> {
         }
         ignite
     }
+    /// Soul Speed (`data/minecraft/enchantment/soul_speed.json`), the parts of
+    /// `Enchantment.runLocationChangedEffects` and `tick` that file uses. The
+    /// `location_changed` effects run when the player enters a new block, lands,
+    /// or its boots change:
+    /// - the speed and movement efficiency modifiers turn on over a soul speed
+    ///   block (not flying, not riding) and stay on while airborne, then off
+    ///   (`enchantment_active_check`);
+    /// - the boots lose 1 durability with a 4% chance when on such a block.
+    ///
+    /// Every fifth tick the player walking on one also gets a soul particle
+    /// (returned as its position and velocity, for the caller to show or send
+    /// to the players around) and sometimes a sound. Runs for the window's own
+    /// player and for each guest on the server (`guest_server_tick`); a remote
+    /// client leaves it to its server.
+    pub(super) fn tick_soul_speed(&mut self) -> Option<([f64; 3], [f64; 3])> {
+        const ID: &str = "minecraft:soul_speed";
+        let player = self.player.as_mut()?;
+        if player.client_side {
+            return None;
+        }
+        let level = self.armor[3]
+            .as_ref()
+            .map_or(0, |s| s.enchantment_level(ID));
+        let position = player.position;
+        let (on_ground, flying) = (player.ground.on_ground, player.flying);
+        let moved = position.subtract(player.old_position);
+        let (tick, width) = (player.health.tick_count, player.dimensions.width);
+        let fx = &mut player.location_effects;
+        let on_soul = fx.on_soul_speed_block;
+        let block = BlockPos::containing(position);
+        let changed_block = fx.block.replace(block) != Some(block);
+        let landed = std::mem::take(&mut fx.landed);
+        // Changed boots: `stopLocationBasedEffects`, then the effects run again.
+        let equipped = std::mem::replace(&mut fx.boots_level, level) != level;
+        let was_active = fx.applied_level;
+        let mut active = was_active > 0 && !equipped;
+        let mut wear = false;
+        if level > 0 && (changed_block || landed || equipped) {
+            let riding = self.riding.is_some();
+            let wanted = !riding && !flying && (on_soul || (active && !on_ground));
+            active = wanted;
+            // `random_chance` is the first term of the wear's `all_of`: it
+            // draws from the level random before the block is looked at.
+            let roll = self.world.random.next_float() < 0.04;
+            wear = roll && on_ground && on_soul;
+        }
+        fx.applied_level = if active { level } else { 0 };
+        // `Entity.getKnownMovement` horizontal speed of at least 1.0E-5.
+        let walking = moved.x * moved.x + moved.z * moved.z >= 1.0e-10;
+        let tick_effects = level > 0 && !flying && on_ground && walking && on_soul && tick % 5 == 0;
+        // The attribute effects were applied to the player before: swap them.
+        if was_active > 0 && (!active || equipped) {
+            for (attribute, id, _, op) in
+                soul_speed_modifiers(&self.res.stations().enchantments, was_active)
+            {
+                let _ = player.set_modifier(&attribute, &id, 0.0, &op, false);
+            }
+        }
+        if active && (was_active == 0 || equipped) {
+            for (attribute, id, amount, op) in
+                soul_speed_modifiers(&self.res.stations().enchantments, level)
+            {
+                let _ = player.set_modifier(&attribute, &id, amount, &op, true);
+            }
+        }
+        if wear && !self.creative {
+            self.wear_boots(1);
+        }
+        if level == 0 {
+            return None;
+        }
+        let r = &mut self.world.random;
+        // `spawn_particles`: in the bounding box, 0.1 above the feet, thrown
+        // back against the movement (-0.2) and up (0.1).
+        let particle = tick_effects.then(|| {
+            let x = position.x + (r.next_double() - 0.5) * f64::from(width);
+            let z = position.z + (r.next_double() - 0.5) * f64::from(width);
+            (
+                [x, position.y + 0.1, z],
+                [moved.x * -0.2, 0.1, moved.z * -0.2],
+            )
+        });
+        // `play_sound`: its `random_chance` (35%) comes first in its `all_of`,
+        // so the level random is drawn every tick the boots are worn; volume
+        // 0.6, pitch 0.6 to 1.0.
+        if r.next_float() < 0.35 && tick_effects {
+            let pitch = r.next_float() * 0.4 + 0.6;
+            self.audio.play(
+                "minecraft:particle.soul_escape",
+                Some([position.x, position.y, position.z]),
+                0.6,
+                pitch,
+            );
+        }
+        particle
+    }
+    /// `ItemStack.hurtAndBreak` on the worn boots (`change_item_damage`):
+    /// Unbreaking applies, and they break when worn out.
+    fn wear_boots(&mut self, amount: u32) {
+        let Some(stack) = self.armor[3].clone() else {
+            return;
+        };
+        let loss = self.durability_loss(&stack, amount);
+        let max = self
+            .res
+            .items()
+            .get(&stack.item)
+            .map_or(0, |info| info.max_damage);
+        if max == 0 {
+            return;
+        }
+        let Some(boots) = self.armor[3].as_mut() else {
+            return;
+        };
+        boots.damage += loss;
+        if boots.damage >= max {
+            self.armor[3] = None;
+            if let Some(eye) = self.eye_position() {
+                self.audio.play(
+                    "minecraft:entity.item.break",
+                    Some(eye),
+                    0.8,
+                    0.8 + self.world.random.next_float() * 0.4,
+                );
+            }
+            self.apply_equipment();
+        }
+    }
     /// Enchantment attribute modifiers of worn armor (respiration, depth strider...).
     /// Each piece's modifier id ends with its slot (`EnchantmentAttributeEffect.idForSlot`),
     /// so the same enchantment on two pieces stacks instead of replacing itself.
@@ -479,3 +659,28 @@ impl Game<'_> {
         self.potions.enchant_modifiers = wanted;
     }
 }
+
+/// Soul Speed's `attribute` effects at `level` (attribute, id, amount, operation),
+/// the id taking the boots slot like `EnchantmentAttributeEffect.idForSlot`.
+fn soul_speed_modifiers(
+    enchantments: &Enchantments,
+    level: u32,
+) -> Vec<(String, String, f64, String)> {
+    let Some(e) = enchantments.get("minecraft:soul_speed") else {
+        return Vec::new();
+    };
+    e.effects["minecraft:location_changed"][0]["effect"]["effects"]
+        .as_array()
+        .into_iter()
+        .flatten()
+        .filter(|a| a["type"] == "minecraft:attribute")
+        .map(|a| {
+            (
+                a["attribute"].as_str().unwrap_or("").to_owned(),
+                format!("{}/feet", a["id"].as_str().unwrap_or("")),
+                f64::from(level_value(&a["amount"], level)),
+                a["operation"].as_str().unwrap_or("add_value").to_owned(),
+            )
+        })
+        .collect()
+}
diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs
index 32d5113b0..41c4e1628 100644
--- a/crates/horizon-client/src/game/end.rs
+++ b/crates/horizon-client/src/game/end.rs
@@ -5,6 +5,7 @@
 use super::{Dim, Game};
 use horizon_client::{
     Result,
+    containers::{BlockEntity, EndGateway},
     environment::Environment,
     items::ItemStack,
     mesher::Vertex,
@@ -19,7 +20,7 @@ use horizon_core::{
 use std::{collections::HashMap, sync::Arc};
 
 /// ServerLevel.END_SPAWN_POINT.
-const END_SPAWN: [i32; 3] = [100, 50, 0];
+pub(super) const END_SPAWN: [i32; 3] = [100, 50, 0];
 /// EnderDragonFight gateway ring radius and height.
 const GATEWAY_RADIUS: f64 = 96.0;
 const GATEWAY_Y: i32 = 75;
@@ -27,14 +28,64 @@ const GATEWAY_Y: i32 = 75;
 const GATEWAY_FILE: &str = "horizon-end-gateways.json";
 
 /// A gateway teleport waiting for its destination chunks.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub(super) enum GatewayJob {
     /// TheEndGatewayBlockEntity.findOrCreateValidTeleportPos from this gateway.
-    Find { gateway: [i32; 3] },
+    /// `exact` is the gateway's own `ExactTeleport`, read while its chunk is loaded.
+    Find { gateway: [i32; 3], exact: bool },
     /// A known exit (exact, or findExitPosition around it).
     Known { exit: [i32; 3], exact: bool },
 }
 
+impl GatewayJob {
+    /// TheEndGatewayBlockEntity.getPortalPosition, with legacy save fallbacks.
+    fn for_gateway(
+        gateway: [i32; 3],
+        entity: Option<&BlockEntity>,
+        legacy: Option<([i32; 3], bool)>,
+    ) -> Self {
+        let configured = match entity {
+            Some(BlockEntity::EndGateway(g)) => g.exit_portal.map(|exit| (exit, g.exact_teleport)),
+            _ => None,
+        };
+        match configured.or(legacy) {
+            Some((exit, exact)) => Self::Known { exit, exact },
+            // Worldgen return gateways (end_gateway_return) lead exactly to the End spawn.
+            None if f64::from(gateway[0]).hypot(f64::from(gateway[2])) > 512.0 => Self::Known {
+                exit: END_SPAWN,
+                exact: true,
+            },
+            None => Self::Find {
+                gateway,
+                exact: exact_teleport(entity),
+            },
+        }
+    }
+}
+
+/// `TheEndGatewayBlockEntity.exactTeleport` of the block entity at a gateway
+/// (false without one).
+fn exact_teleport(entity: Option<&BlockEntity>) -> bool {
+    matches!(entity, Some(BlockEntity::EndGateway(g)) if g.exact_teleport)
+}
+
+/// Moves an exit that only the side file knew into the gateway's block entity, unless the block
+/// entity has its own; true when it took the saved one.
+fn adopt_saved_exit(entity: &mut EndGateway, (exit, exact): ([i32; 3], bool)) -> bool {
+    if entity.exit_portal.is_some() {
+        return false;
+    }
+    entity.exit_portal = Some(exit);
+    entity.exact_teleport = exact;
+    true
+}
+
+/// The end of `getPortalPosition`: the exit itself when the teleport is exact,
+/// else the spot [`Game::resolve_gateway`] finds around it (`findExitPosition`).
+fn exit_target(exit: [i32; 3], exact: bool, find: impl FnOnce([i32; 3]) -> [i32; 3]) -> [i32; 3] {
+    if exact { exit } else { find(exit) }
+}
+
 #[derive(Default)]
 pub(super) struct EndState {
     /// Gateway position -> (exit, exact teleport); loaded lazily from the save.
@@ -247,16 +298,25 @@ impl Game<'_> {
                     layer: 2,
                     color,
                     light: 0,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
         out
     }
 
-    /// LightmapRenderStateExtractor: End flashes add to the sky light factor.
+    /// LightmapRenderStateExtractor: End flashes add to the sky light factor
+    /// unless Hide Lightning Flashes is on (the sky sprite is not gated), a
+    /// third of it under a boss bar's world fog.
     pub(super) fn end_flash_sky(&self, sky: &mut horizon_client::environment::Sky, partial: f64) {
-        if self.dim == Dim::End {
-            sky.sky_light_factor += self.end.flash.intensity(partial as f32);
+        if self.dim == Dim::End && !self.settings.file.bool("hideLightningFlashes") {
+            let intensity = self.end.flash.intensity(partial as f32);
+            sky.sky_light_factor += if self.boss_overlay.should_create_world_fog() {
+                intensity / 3.0
+            } else {
+                intensity
+            };
         }
     }
 
@@ -599,7 +659,9 @@ impl Game<'_> {
 
     /// EnderDragonFight without a dragon: once the centre of the main island
     /// is loaded, place the active exit portal (EndPodiumFeature) and the
-    /// first gateway (spawnNewGateway) if the portal is not there yet.
+    /// first gateway (spawnNewGateway) if the portal is not there yet. Like
+    /// scanState and spawnExitPortal, only while the fight has no exit portal
+    /// location: a podium that is later broken stays broken.
     fn ensure_exit_portal(&mut self) -> Result<()> {
         if self.travelling.is_some()
             || !(-1..=0).all(|cz| (-1..=0).all(|cx| self.streaming.is_lit(cx, cz)))
@@ -609,8 +671,14 @@ impl Game<'_> {
         }
         let won = self.fight.previously_killed;
         let gateway = self.first_gateway();
-        if (0..256).any(|y| &*self.block_name([0, y, 0]) == "minecraft:bedrock") {
-            // The podium exists; the gateway may have been out of range when it was placed.
+        if self.exit_portal().is_none() {
+            // findExitPortal remembers the location of a podium that is already there.
+            if let Some(level) = self.podium_level() {
+                self.set_exit_portal([0, level, 0]);
+            }
+        }
+        if self.exit_portal().is_some() {
+            // The gateway may have been out of range when it was placed.
             if won
                 && self.world.loaded(gateway[0], gateway[2])
                 && &*self.block_name(gateway) != "minecraft:end_gateway"
@@ -641,17 +709,40 @@ impl Game<'_> {
         }
         Ok(())
     }
+    /// The portal level of the podium around the centre column, read from the
+    /// bedrock that EndPodiumFeature places (rim at the portal level, disc
+    /// below it, the torch column) so a broken column does not hide it.
+    fn podium_level(&self) -> Option<i32> {
+        let mut offsets: Vec<[i32; 3]> = (0..4).map(|dy| [0, dy, 0]).collect();
+        for z in -4..=4i32 {
+            for x in -4..=4i32 {
+                let flat = f64::from(x * x + z * z);
+                if (6.25..12.25).contains(&flat) {
+                    offsets.push([x, 0, z]);
+                } else if flat + 1.0 < 6.25 {
+                    offsets.push([x, -1, z]);
+                }
+            }
+        }
+        (1..253)
+            .map(|y| {
+                let score = offsets
+                    .iter()
+                    .filter(|o| &*self.block_name([o[0], y + o[1], o[2]]) == "minecraft:bedrock")
+                    .count();
+                (score, y)
+            })
+            .filter(|&(score, _)| score >= 3)
+            .max()
+            .map(|(_, y)| y)
+    }
     /// `spawnExitPortal(true)` after the dragon dies.
     pub(super) fn activate_exit_portal(&mut self) -> Result<()> {
         let origin = match self.exit_portal() {
             Some(o) => o,
             None => {
-                // The rim's level: the top of the bedrock column minus three.
-                let top = (0..256)
-                    .rev()
-                    .find(|&y| &*self.block_name([0, y, 0]) == "minecraft:bedrock")
-                    .unwrap_or(64);
-                [0, top - 3, 0]
+                // The rim's level, found without assuming the centre column is intact.
+                [0, self.podium_level().unwrap_or(61), 0]
             }
         };
         self.place_podium(origin, true)
@@ -754,6 +845,11 @@ impl Game<'_> {
                 }
             }
         }
+        self.world
+            .block_entities
+            .get_or_insert_with((origin[0], origin[1], origin[2]), || {
+                BlockEntity::EndGateway(Default::default())
+            });
         Ok(())
     }
 
@@ -775,8 +871,7 @@ impl Game<'_> {
         self.end.exits.as_mut().expect("loaded exits")
     }
 
-    fn set_gateway_exit(&mut self, gateway: [i32; 3], exit: [i32; 3], exact: bool) -> Result<()> {
-        self.gateway_exits().insert(gateway, (exit, exact));
+    fn save_gateway_exits(&mut self) -> Result<()> {
         let list: Vec<_> = self
             .gateway_exits()
             .iter()
@@ -788,6 +883,35 @@ impl Game<'_> {
         Ok(())
     }
 
+    /// Drops a gateway's entry from the side file: its block entity is the source of truth.
+    fn forget_gateway_exit(&mut self, gateway: [i32; 3]) -> Result<()> {
+        if self.gateway_exits().remove(&gateway).is_some() {
+            self.save_gateway_exits()?;
+        }
+        Ok(())
+    }
+
+    fn set_gateway_exit(&mut self, gateway: [i32; 3], exit: [i32; 3], exact: bool) -> Result<()> {
+        // TheEndGatewayBlockEntity.setExitPosition (also EndGatewayFeature.knownExit).
+        let key = (gateway[0], gateway[1], gateway[2]);
+        let chunk = (gateway[0] >> 4, gateway[2] >> 4);
+        // The gateway's chunk can be unloaded by now (travel waits for the destination): the
+        // exit then waits in the side file until the gateway is used again (`gateway_job`).
+        if self.world.chunks.contains_key(&chunk)
+            && let BlockEntity::EndGateway(g) = self
+                .world
+                .block_entities
+                .get_or_insert_with(key, || BlockEntity::EndGateway(Default::default()))
+        {
+            g.exit_portal = Some(exit);
+            g.exact_teleport = exact;
+            self.world.modified.insert(chunk);
+            return self.forget_gateway_exit(gateway);
+        }
+        self.gateway_exits().insert(gateway, (exit, exact));
+        self.save_gateway_exits()
+    }
+
     /// EndGatewayBlock.entityInside and TheEndGatewayBlockEntity.getPortalPosition:
     /// travel within the End, waiting for the destination chunks to load.
     fn enter_gateway(&mut self, gateway: [i32; 3]) -> Result<()> {
@@ -807,25 +931,39 @@ impl Game<'_> {
     /// its exit, or the search for one, and the spot to load before either
     /// is resolved ([`Game::resolve_gateway`]).
     pub(super) fn gateway_job(&mut self, gateway: [i32; 3]) -> (GatewayJob, Vec3) {
-        let known = self.gateway_exits().get(&gateway).copied();
-        let job = match known {
-            Some((exit, exact)) => GatewayJob::Known { exit, exact },
-            // Worldgen return gateways (end_gateway_return) lead exactly to the End spawn.
-            None if f64::from(gateway[0]).hypot(f64::from(gateway[2])) > 512.0 => {
-                GatewayJob::Known {
-                    exit: END_SPAWN,
-                    exact: true,
-                }
+        let mut known = self.gateway_exits().get(&gateway).copied();
+        // Once the gateway's chunk is loaded its block entity is the source of truth: an exit the
+        // side file kept for it moves there, and the entry is dropped, so removing or replacing
+        // the exit (`/data remove block`) is not undone by an old entry.
+        let key = (gateway[0], gateway[1], gateway[2]);
+        let chunk = (gateway[0] >> 4, gateway[2] >> 4);
+        if let Some(saved) = known
+            && self.world.chunks.contains_key(&chunk)
+            && let BlockEntity::EndGateway(g) = self
+                .world
+                .block_entities
+                .get_or_insert_with(key, || BlockEntity::EndGateway(Default::default()))
+        {
+            if adopt_saved_exit(g, saved) {
+                self.world.modified.insert(chunk);
             }
-            None => GatewayJob::Find { gateway },
-        };
+            known = None;
+            let _ = self.forget_gateway_exit(gateway);
+        }
+        let job = GatewayJob::for_gateway(
+            gateway,
+            self.world
+                .block_entities
+                .get(&(gateway[0], gateway[1], gateway[2])),
+            known,
+        );
         let destination = match job {
             GatewayJob::Known { exit, .. } => Vec3::new(
                 f64::from(exit[0]) + 0.5,
                 f64::from(exit[1]),
                 f64::from(exit[2]) + 0.5,
             ),
-            GatewayJob::Find { gateway } => {
+            GatewayJob::Find { gateway, .. } => {
                 let d = glam::DVec2::new(f64::from(gateway[0]), f64::from(gateway[2]))
                     .normalize_or_zero()
                     * 1024.0;
@@ -882,12 +1020,10 @@ impl Game<'_> {
             [p[0], p[1] + 1, p[2]]
         };
         match job {
-            GatewayJob::Known { exit, exact } => Ok(bottom_center(if exact {
-                exit
-            } else {
-                find_exit(self, exit)
-            })),
-            GatewayJob::Find { gateway } => {
+            GatewayJob::Known { exit, exact } => Ok(bottom_center(exit_target(exit, exact, |e| {
+                find_exit(self, e)
+            }))),
+            GatewayJob::Find { gateway, exact } => {
                 // findExitPortalXZPosTentative over the loaded chunks.
                 let dir = glam::DVec2::new(f64::from(gateway[0]), f64::from(gateway[2]))
                     .normalize_or_zero();
@@ -947,8 +1083,11 @@ impl Game<'_> {
                 let exit = [tallest[0], tallest[1] + 10, tallest[2]];
                 self.place_gateway(exit)?;
                 self.set_gateway_exit(exit, gateway, false)?;
-                self.set_gateway_exit(gateway, exit, false)?;
-                Ok(bottom_center(find_exit(self, exit)))
+                // setExitPosition keeps the gateway's own exactTeleport.
+                self.set_gateway_exit(gateway, exit, exact)?;
+                Ok(bottom_center(exit_target(exit, exact, |e| {
+                    find_exit(self, e)
+                })))
             }
         }
     }
@@ -1240,8 +1379,103 @@ impl Game<'_> {
                     layer: 0,
                     color: 0xFFFF_FFFF,
                     light: full,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use horizon_client::containers::EndGateway;
+
+    #[test]
+    fn a_saved_exit_moves_into_a_gateway_without_one() {
+        let saved = ([8, 100, 0], true);
+        let mut bare = EndGateway::default();
+        assert!(adopt_saved_exit(&mut bare, saved));
+        assert_eq!(bare.exit_portal, Some([8, 100, 0]));
+        assert!(bare.exact_teleport);
+        // The block entity's own exit wins over a stale entry.
+        let mut own = EndGateway {
+            exit_portal: Some([1, 2, 3]),
+            ..Default::default()
+        };
+        assert!(!adopt_saved_exit(&mut own, saved));
+        assert_eq!(own.exit_portal, Some([1, 2, 3]));
+        assert!(!own.exact_teleport);
+    }
+
+    #[test]
+    fn a_new_exit_keeps_the_gateways_exact_teleport() {
+        let exact = BlockEntity::EndGateway(EndGateway {
+            exact_teleport: true,
+            ..Default::default()
+        });
+        let plain = BlockEntity::EndGateway(EndGateway::default());
+        assert!(exact_teleport(Some(&exact)));
+        assert!(!exact_teleport(Some(&plain)));
+        assert!(!exact_teleport(None));
+        assert!(!exact_teleport(Some(&BlockEntity::DaylightDetector)));
+        let exit = [8, 100, 0];
+        // Exact: the exit itself, nothing is searched for.
+        assert_eq!(exit_target(exit, true, |_| panic!("searched")), exit);
+        assert_eq!(
+            exit_target(exit, false, |e| [e[0], e[1] + 11, e[2]]),
+            [8, 111, 0]
+        );
+    }
+
+    #[test]
+    fn end_gateway_job_prefers_block_entity_then_legacy_then_heuristic() {
+        let gateway = [702, 100, 0];
+        let exit = [8, 100, 0];
+        for exact in [true, false] {
+            let entity = BlockEntity::EndGateway(EndGateway {
+                exit_portal: Some(exit),
+                exact_teleport: exact,
+                ..Default::default()
+            });
+            assert_eq!(
+                GatewayJob::for_gateway(gateway, Some(&entity), Some((END_SPAWN, !exact))),
+                GatewayJob::Known { exit, exact },
+            );
+        }
+        let empty = BlockEntity::EndGateway(EndGateway::default());
+        for entity in [None, Some(&empty)] {
+            assert_eq!(
+                GatewayJob::for_gateway(gateway, entity, Some((exit, false))),
+                GatewayJob::Known { exit, exact: false }
+            );
+            assert_eq!(
+                GatewayJob::for_gateway(gateway, entity, None),
+                GatewayJob::Known {
+                    exit: END_SPAWN,
+                    exact: true
+                }
+            );
+            let nearby = [96, 75, 0];
+            let exact = BlockEntity::EndGateway(EndGateway {
+                exact_teleport: true,
+                ..Default::default()
+            });
+            assert_eq!(
+                GatewayJob::for_gateway(nearby, Some(&exact), None),
+                GatewayJob::Find {
+                    gateway: nearby,
+                    exact: true
+                }
+            );
+            assert_eq!(
+                GatewayJob::for_gateway(nearby, entity, None),
+                GatewayJob::Find {
+                    gateway: nearby,
+                    exact: false
+                }
+            );
+        }
+    }
+}
diff --git a/crates/horizon-client/src/game/entity_culling.rs b/crates/horizon-client/src/game/entity_culling.rs
index 66fbaa3e4..971639a42 100644
--- a/crates/horizon-client/src/game/entity_culling.rs
+++ b/crates/horizon-client/src/game/entity_culling.rs
@@ -60,12 +60,27 @@ impl Game<'_> {
     }
 }
 
+impl Game<'_> {
+    /// Entity.setViewScale (LevelExtractor.extractVisibleEntities): the entity
+    /// distance option times the render distance's boost — 1 at 8 chunks, 2.5
+    /// at 20 or more. The render distance is the client setting, capped by
+    /// the server's view distance when connected
+    /// (Options.getEffectiveRenderDistance).
+    pub(super) fn view_scale(&self) -> f64 {
+        let distance = match &self.remote {
+            Some(r) => self.settings.render_distance.min(r.view_distance),
+            None => self.settings.render_distance,
+        };
+        (f64::from(distance) / 8.0).clamp(1.0, 2.5) * f64::from(self.settings.entity_distance)
+    }
+}
+
 /// Entity.shouldRenderAtSqrDistance's default range: 64 times the bounding
-/// box's mean edge, scaled by the entity distance option.
-pub(super) fn default_range(size: glam::DVec3, view_scale: f32) -> f64 {
+/// box's mean edge, scaled by the view scale.
+pub(super) fn default_range(size: glam::DVec3, view_scale: f64) -> f64 {
     let edge = (size.x + size.y + size.z) / 3.0;
     let edge = if edge.is_nan() { 1.0 } else { edge };
-    edge * 64.0 * f64::from(view_scale)
+    edge * 64.0 * view_scale
 }
 
 impl Game<'_> {
diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs
index 6ecba3a54..88ef4263a 100644
--- a/crates/horizon-client/src/game/explosion.rs
+++ b/crates/horizon-client/src/game/explosion.rs
@@ -296,15 +296,23 @@ impl Game<'_> {
             if !creative
                 && !spectator
                 && hurtable
-                && let Ok(o) = p.hurt_blocking(
+                && let Ok(o) = p.hurt_caused_by(
                     &self.motion.health,
                     self.world.health_rules,
                     id,
                     amount,
                     blocking,
+                    // The exploding mob is the causing entity.
+                    exploding.is_some(),
                 )
             {
                 outcome = o;
+                // dealDefaultKnockback's `indicateDamage` points at the blast
+                // (the source position), not the no-direction fallback.
+                if o.knockback && o.blocked <= 0.0 {
+                    p.health
+                        .indicate_damage(center[0] - feet[0], center[2] - feet[2], p.yaw);
+                }
             }
             if !spectator && !(creative && flying) {
                 p.velocity = Vec3::new(
@@ -314,9 +322,6 @@ impl Game<'_> {
                 );
             }
         }
-        if outcome.hurt && !creative {
-            self.hurt_armor(amount);
-        }
         if raised {
             self.after_block(outcome, amount, None, false);
         }
@@ -391,9 +396,18 @@ impl Game<'_> {
                 [feet[0] - w, feet[1], feet[2] - w],
                 [feet[0] + w, feet[1] + h, feet[2] + w],
             );
+            // The exploding mob is the damage source's entity, so victims
+            // it kills drop its charged-creeper loot (`Creeper.killedEntity`).
             let source = horizon_client::mobs::Damage {
                 kind: horizon_client::mobs::DamageKind::Explosion,
-                attacker: None,
+                // A projectile's owner (`getIndirectSourceEntity`), else
+                // the exploding mob itself.
+                attacker: self
+                    .combat
+                    .explosion_owner
+                    .or(exploding)
+                    .filter(|&o| o != m.id)
+                    .map(horizon_client::mobs::Who::Mob),
                 from: Some(center),
             };
             if hurtable && !m.damage(damage(dist, exposure), source) {
@@ -489,6 +503,15 @@ impl Game<'_> {
             );
         }
     }
+    /// Runs an explosion whose source empties the hives it destroys
+    /// (`BeehiveBlock.getDrops`: primed TNT, creeper, wither skull, wither,
+    /// TNT minecart).
+    pub(super) fn with_hive_emptying_blast<R>(&mut self, blast: impl FnOnce(&mut Self) -> R) -> R {
+        self.combat.hive_emptying_blast = true;
+        let result = blast(self);
+        self.combat.hive_emptying_blast = false;
+        result
+    }
     /// `Level.explode` on the server: positions, entities, blocks, fire; then
     /// the client's explosion sound.
     pub(super) fn server_explode(
@@ -571,16 +594,16 @@ impl Game<'_> {
         let pitch = (1.0 + (client_float() - client_float()) * 0.2) * 0.7;
         self.audio
             .play("minecraft:entity.generic.explode", Some(center), 4.0, pitch);
-        let block_count = if interaction == BlockInteraction::Keep {
-            0
-        } else {
-            targets.len()
-        };
+        // ServerLevel.explode sends toBlow.size() whatever the interaction, and
+        // `ServerExplosion.isSmall` also covers an explosion that keeps blocks.
+        let block_count = targets.len();
+        let small = radius < 2.0 || interaction == BlockInteraction::Keep;
         let (world, facts) = (&self.world, self.res.facts());
-        self.particles.explosion(center, radius, block_count, &|b| {
-            facts.is_air(world.block(b[0], b[1], b[2]))
-        });
-        self.lan_explode(center, radius, block_count);
+        self.particles
+            .explosion(center, small, block_count, radius, &|b| {
+                facts.is_air(world.block(b[0], b[1], b[2]))
+            });
+        self.lan_explode(center, small, radius, block_count);
         Ok(())
     }
     /// `BlockBehaviour.onExplosionHit` (TNT: `wasExploded` primes a short fuse).
@@ -597,9 +620,30 @@ impl Game<'_> {
         }
         let name = self.res.facts().get(state).name.clone();
         let is_tnt = &*name == "minecraft:tnt";
+        // CreakingHeartBlock.onExplosionHit: its creaking dies (no
+        // experience, as Horizon does not track a TNT's owner).
+        if &*name == "minecraft:creaking_heart" {
+            self.creaking_heart_broken(pos, false);
+        }
         // Block.onExplosionHit: the drops copy from the block entity, which
         // then spills its contents as the block turns to air.
         let key = (pos[0], pos[1], pos[2]);
+        let is_hive = matches!(&*name, "minecraft:beehive" | "minecraft:bee_nest");
+        // BeehiveBlock.getDrops: the bees of a hive blown up by TNT, a
+        // creeper, a wither skull, a wither or a TNT minecart come out.
+        if is_hive && self.combat.hive_emptying_blast {
+            let facing = self
+                .pack
+                .assets
+                .registry
+                .state(state)
+                .and_then(|s| s.properties.get("facing").cloned());
+            self.empty_hive(
+                pos,
+                horizon_client::beehive::facing_step(facing.as_deref()),
+                horizon_client::beehive::Release::Emergency,
+            );
+        }
         if let Some(entity) = self.world.block_entities.get(&key).cloned() {
             let custom = self.world.block_names.get(&key).cloned();
             self.pending.record(pos, &entity, &name, custom);
@@ -620,6 +664,7 @@ impl Game<'_> {
                 &mut self.world.random,
                 Some((&mut self.rand_sequences, self.level.seed)),
                 decay,
+                false,
             );
             for mut stack in drops {
                 if &*stack.item == "minecraft:air" || stack.count == 0 {
@@ -631,6 +676,10 @@ impl Game<'_> {
         }
         self.pending.clear(pos);
         self.level_set(pos, self.world.air)?;
+        // BeehiveBlock.onExplosionHit: the bees about turn on the player.
+        if is_hive {
+            self.anger_nearby_bees(pos);
+        }
         // TntBlock.wasExploded: new PrimedTnt (its push drawn first), then
         // getRandomShortFuse(80); no game event.
         if is_tnt && self.ui.rules.bool("tnt_explodes") {
diff --git a/crates/horizon-client/src/game/falling_damage.rs b/crates/horizon-client/src/game/falling_damage.rs
index 8eec28d1d..41c714561 100644
--- a/crates/horizon-client/src/game/falling_damage.rs
+++ b/crates/horizon-client/src/game/falling_damage.rs
@@ -64,6 +64,25 @@ impl Game<'_> {
                     pos: BlockPos::new(pos[0], pos[1], pos[2]),
                     data: 0,
                 });
+            } else if self
+                .res
+                .facts()
+                .get(block.state)
+                .name
+                .starts_with("minecraft:suspicious_")
+            {
+                // BrushableBlock.onBrokenAfterFall.
+                let at = BlockPos::new(pos[0], pos[1], pos[2]);
+                self.level_events.push(LevelEvent::LevelEvent {
+                    id: 2001,
+                    pos: at,
+                    data: block.state.0 as i32,
+                });
+                self.level_events.push(LevelEvent::GameEvent {
+                    pos: at,
+                    event: "minecraft:block_destroy",
+                    state: None,
+                });
             }
             return;
         }
@@ -108,16 +127,10 @@ impl Game<'_> {
         } else {
             amount
         };
-        let hurt = if let Some(p) = self.player.as_mut()
+        if let Some(p) = self.player.as_mut()
             && let Some(id) = self.motion.health.damage.id(kind)
         {
-            p.hurt(&self.motion.health, self.world.health_rules, id, amount)
-                .unwrap_or(false)
-        } else {
-            false
-        };
-        if hurt {
-            self.hurt_armor(amount);
+            let _ = p.hurt(&self.motion.health, self.world.health_rules, id, amount);
         }
     }
 }
diff --git a/crates/horizon-client/src/game/fangs.rs b/crates/horizon-client/src/game/fangs.rs
index cdf2d17a5..6c20ccf93 100644
--- a/crates/horizon-client/src/game/fangs.rs
+++ b/crates/horizon-client/src/game/fangs.rs
@@ -7,12 +7,13 @@ use std::sync::Arc;
 
 #[derive(Clone, Debug)]
 pub(super) struct Fangs {
-    pos: [f64; 3],
-    yaw: f32,
+    pub id: u32,
+    pub pos: [f64; 3],
+    pub yaw: f32,
     warmup: i32,
-    life: i32,
+    pub life: i32,
     owner: u32,
-    started: bool,
+    pub started: bool,
 }
 #[derive(Default)]
 pub(super) struct FangState {
@@ -21,6 +22,11 @@ pub(super) struct FangState {
 }
 impl Game<'_> {
     pub(super) fn add_fangs(&mut self, at: [f64; 3], yaw: f32, delay: i32, owner: u32) {
+        self.next_entity += 1;
+        self.insert_fangs(self.next_entity, at, yaw, delay, owner);
+    }
+
+    pub(super) fn insert_fangs(&mut self, id: u32, at: [f64; 3], yaw: f32, delay: i32, owner: u32) {
         if self.fangs.model.is_none() {
             self.fangs.model = horizon_client::mobs::load_model(
                 &self.options.resources,
@@ -29,6 +35,7 @@ impl Game<'_> {
             .map(Arc::new);
         }
         self.fangs.list.push(Fangs {
+            id,
             pos: at,
             yaw,
             warmup: delay,
@@ -37,6 +44,30 @@ impl Game<'_> {
             started: false,
         });
     }
+    /// `EvokerFangs.handleEntityEvent`: only event 4 starts a client attack.
+    pub(super) fn remote_fangs_event(&mut self, id: u32, event: i8) {
+        if event == 4
+            && let Some(f) = self.fangs.list.iter_mut().find(|f| f.id == id)
+        {
+            f.started = true;
+            self.audio.play_unshared(
+                "minecraft:entity.evoker_fangs.attack",
+                Some(f.pos),
+                1.0,
+                1.0,
+            );
+        }
+    }
+
+    /// `EvokerFangs.tick`: clients only advance animation, never damage or discard.
+    pub(super) fn tick_remote_fangs(&mut self) {
+        for f in &mut self.fangs.list {
+            if f.started {
+                f.life -= 1;
+            }
+        }
+    }
+
     /// `EvokerFangs.tick`.
     pub(super) fn tick_fangs(&mut self) {
         let mut list = std::mem::take(&mut self.fangs.list);
@@ -50,7 +81,8 @@ impl Game<'_> {
             }
             if !f.started {
                 f.started = true;
-                self.audio.play(
+                self.lan_entity_event(f.id as i32, 4, f.pos);
+                self.audio.play_unshared(
                     "minecraft:entity.evoker_fangs.attack",
                     Some(f.pos),
                     1.0,
@@ -71,26 +103,49 @@ impl Game<'_> {
         let b = horizon_core::geometry::Aabb::new(lo, hi);
         // Every player in the box, the server's players too.
         let pos = f.pos;
+        // `EvokerFangs.dealDamageTo`: indirectMagic(fangs, owner) while the
+        // owner lives, plain magic (nobody to name) once it is gone.
+        let owner = self
+            .mobs
+            .iter()
+            .any(|m| m.id == f.owner && m.alive())
+            .then_some(f.owner);
         let bite = move |g: &mut Self| {
             if let Some(p) = g.player_view()
                 && p.alive
                 && p.bounds.intersects(b)
             {
-                g.mob_hits_player_kind(6.0, pos, "minecraft:indirect_magic");
+                let kind = match owner {
+                    Some(_) => "minecraft:indirect_magic",
+                    None => "minecraft:magic",
+                };
+                g.mob_hits_player_caused(6.0, pos, kind, owner);
             }
         };
         bite(self);
         self.each_guest_hit(bite);
+        // `AbstractIllager.considersEntityAsAlly`: with no teams, the illager
+        // tag is allied; `Evoker.considersEntityAsAlly` adds a vex whose
+        // owner is allied (itself or another illager). Teams are not modelled.
+        let illager = |s: Species| {
+            matches!(
+                s,
+                Species::Evoker | Species::Illusioner | Species::Pillager | Species::Vindicator
+            )
+        };
+        let illagers: Vec<u32> = self
+            .mobs
+            .iter()
+            .filter(|m| illager(m.species()))
+            .map(|m| m.id)
+            .collect();
+        // A missing owner hurts everyone (`currentOwner == null`).
+        let owner_known = illagers.contains(&f.owner);
         for m in &mut self.mobs {
-            let ally = matches!(
-                m.species(),
-                Species::Evoker
-                    | Species::Illusioner
-                    | Species::Vex
-                    | Species::Pillager
-                    | Species::Vindicator
-                    | Species::Witch
-            );
+            let ally = owner_known
+                && (illager(m.species())
+                    || m.species() == Species::Vex
+                        && illagers.contains(&(m.extra.counter2 as u32)));
             if m.id != f.owner && !ally && m.alive() && m.bounds().intersects(b) {
                 m.damage(
                     6.0,
diff --git a/crates/horizon-client/src/game/fireworks.rs b/crates/horizon-client/src/game/fireworks.rs
index fd160a920..f66fd4d3a 100644
--- a/crates/horizon-client/src/game/fireworks.rs
+++ b/crates/horizon-client/src/game/fireworks.rs
@@ -23,7 +23,7 @@ pub(super) struct Rocket {
     /// The entity id a server tracks it by (0 until it is tracked).
     pub id: u32,
     pub(super) position: Vec3,
-    previous: Vec3,
+    pub(super) previous: Vec3,
     pub(super) velocity: Vec3,
     life: i32,
     lifetime: i32,
@@ -62,11 +62,56 @@ impl Rocket {
             item,
         }
     }
-    /// One tick of a server's client: the previous position, then `step`.
-    pub(super) fn remote_step(&mut self, step: impl FnOnce(Vec3) -> Vec3) {
+    /// One tick of a server's client: the rocket flies on by itself between
+    /// the server's updates (a rocket that follows an entity is placed by the
+    /// caller).
+    pub(super) fn remote_step(&mut self, scene: &mut SceneCollisions) {
         self.previous = self.position;
+        if self.attached_to.is_none() {
+            self.free_flight(scene);
+        }
         self.life += 1;
-        self.position = step(self.position);
+    }
+    /// `FireworkRocketEntity.tick` for a rocket attached to no entity: speed
+    /// up (an angled one keeps its motion) and rise, then move. True when a
+    /// block stopped it.
+    fn free_flight(&mut self, scene: &mut SceneCollisions) -> bool {
+        let h = 0.125;
+        let bounds = Aabb::new(
+            Vec3::new(self.position.x - h, self.position.y, self.position.z - h),
+            Vec3::new(
+                self.position.x + h,
+                self.position.y + 2.0 * h,
+                self.position.z + h,
+            ),
+        );
+        let wanted = if self.angled {
+            self.velocity
+        } else {
+            Vec3::new(
+                self.velocity.x * 1.15,
+                self.velocity.y + 0.04,
+                self.velocity.z * 1.15,
+            )
+        };
+        let Ok(moved) = scene.resolve(bounds, wanted, 0.0, false) else {
+            return false;
+        };
+        let blocked = (moved.x - wanted.x).abs() > 1e-7
+            || (moved.y - wanted.y).abs() > 1e-7
+            || (moved.z - wanted.z).abs() > 1e-7;
+        let horizontal = (moved.x - wanted.x).abs() > 1e-7 || (moved.z - wanted.z).abs() > 1e-7;
+        self.position = Vec3::new(
+            self.position.x + moved.x,
+            self.position.y + moved.y,
+            self.position.z + moved.z,
+        );
+        self.velocity = if horizontal {
+            Vec3::new(self.velocity.x, wanted.y, self.velocity.z)
+        } else {
+            wanted
+        };
+        blocked
     }
     /// Position and motion (the dispenser parity fixture).
     pub(super) fn motion(&self) -> (Vec3, Vec3) {
@@ -191,46 +236,14 @@ impl Game<'_> {
                     r.velocity = p.velocity;
                 }
             } else {
-                // Not shot at an angle: accelerate (unless blocked sideways) and rise.
                 let mut scene = SceneCollisions {
                     world: &self.world,
                     binding: self.collision,
                     subject: None,
                 };
-                let h = 0.125;
-                let bounds = Aabb::new(
-                    Vec3::new(r.position.x - h, r.position.y, r.position.z - h),
-                    Vec3::new(r.position.x + h, r.position.y + 2.0 * h, r.position.z + h),
-                );
-                let wanted = if r.angled {
-                    r.velocity
-                } else {
-                    Vec3::new(
-                        r.velocity.x * 1.15,
-                        r.velocity.y + 0.04,
-                        r.velocity.z * 1.15,
-                    )
-                };
-                if let Ok(moved) = scene.resolve(bounds, wanted, 0.0, false) {
-                    let blocked = (moved.x - wanted.x).abs() > 1e-7
-                        || (moved.y - wanted.y).abs() > 1e-7
-                        || (moved.z - wanted.z).abs() > 1e-7;
-                    if r.angled && blocked {
-                        // hitTargetOrDeflectSelf: explode on the block.
-                        r.life = r.lifetime;
-                    }
-                    let horizontal =
-                        (moved.x - wanted.x).abs() > 1e-7 || (moved.z - wanted.z).abs() > 1e-7;
-                    r.position = Vec3::new(
-                        r.position.x + moved.x,
-                        r.position.y + moved.y,
-                        r.position.z + moved.z,
-                    );
-                    r.velocity = if horizontal {
-                        Vec3::new(r.velocity.x, wanted.y, r.velocity.z)
-                    } else {
-                        wanted
-                    };
+                if r.free_flight(&mut scene) && r.angled {
+                    // hitTargetOrDeflectSelf: explode on the block.
+                    r.life = r.lifetime;
                 }
             }
             let at = [r.position.x, r.position.y, r.position.z];
@@ -372,24 +385,23 @@ impl Game<'_> {
         if self.creative || self.spectator() {
             return;
         }
-        let hurt = if let Some(p) = self.player.as_mut()
+        if let Some(p) = self.player.as_mut()
             && !p.health.dead_or_dying()
             && let Some(id) = self.motion.health.damage.id("minecraft:fireworks")
         {
-            p.hurt(&self.motion.health, self.world.health_rules, id, amount)
-                .unwrap_or(false)
-        } else {
-            false
-        };
-        if hurt {
-            self.hurt_armor(amount);
+            let _ = p.hurt(&self.motion.health, self.world.health_rules, id, amount);
         }
     }
     /// `FireworkEntityRenderer.submit`: the item (GROUND) facing the camera,
     /// lit at the rocket's light probe.
     pub(super) fn rocket_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec<Vertex>) {
         let orientation = glam::Mat4::from_quat(self.camera_orientation());
-        for r in self.rockets.iter().filter(|r| !r.attached) {
+        // shouldRender: not while attached to an entity (`isAttachedToEntity`).
+        for r in self
+            .rockets
+            .iter()
+            .filter(|r| !r.attached && r.attached_to.is_none())
+        {
             // FireworkRocketEntity.shouldRenderAtSqrDistance: within 64 blocks;
             // EntityRenderer.shouldRender: its 0.25 box in the view.
             if !self.standing_entity_in_view(
diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs
index 22cb3774b..e3f4fd025 100644
--- a/crates/horizon-client/src/game/fishing.rs
+++ b/crates/horizon-client/src/game/fishing.rs
@@ -2,6 +2,7 @@
 //! bobbing, lure and bite timers, open water, hooking mobs, retrieving the
 //! `gameplay/fishing` loot) and `FishingHookRenderer` (bobber and line).
 use super::{Game, view_vector};
+use horizon_client::advancements::EntityView;
 use horizon_client::lan::{entity::States, hub::Hub};
 use horizon_client::{
     blocks::Fluid,
@@ -30,8 +31,8 @@ enum State {
 pub(super) struct Hook {
     /// Its entity id, which a server's players track it under.
     id: u32,
-    position: Vec3,
-    previous: Vec3,
+    pub(super) position: Vec3,
+    pub(super) previous: Vec3,
     velocity: Vec3,
     state: State,
     life: i32,
@@ -77,7 +78,7 @@ impl Game<'_> {
         let at = [p.position.x, p.position.y, p.position.z];
         let pitch = 0.4 / (self.world.random.next_float() * 0.4 + 0.8);
         if self.hook.is_some() {
-            let damage = self.retrieve_hook();
+            let damage = self.retrieve_hook(stack);
             self.damage_held(damage);
             self.audio.play(
                 "minecraft:entity.fishing_bobber.retrieve",
@@ -143,7 +144,7 @@ impl Game<'_> {
         true
     }
     /// `FishingHook.retrieve`: the rod damage it costs.
-    fn retrieve_hook(&mut self) -> u32 {
+    fn retrieve_hook(&mut self, rod: &ItemStack) -> u32 {
         let Some(hook) = self.hook.take() else {
             return 0;
         };
@@ -154,37 +155,64 @@ impl Game<'_> {
         let mut damage = 0;
         if let State::Hooked(id) = hook.state {
             // pullEntity: 0.1 of the way to the owner.
+            let d = Vec3::new(
+                owner.x - hook.position.x,
+                owner.y - hook.position.y,
+                owner.z - hook.position.z,
+            );
+            let pulled = |v: Vec3| Vec3::new(v.x + d.x * 0.1, v.y + d.y * 0.1, v.z + d.z * 0.1);
+            let mut hooked_item = false;
             if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
-                let d = Vec3::new(
-                    owner.x - hook.position.x,
-                    owner.y - hook.position.y,
-                    owner.z - hook.position.z,
-                );
-                m.velocity = Vec3::new(
-                    m.velocity.x + d.x * 0.1,
-                    m.velocity.y + d.y * 0.1,
-                    m.velocity.z + d.z * 0.1,
-                );
+                m.velocity = pulled(m.velocity);
+            } else if let Some(item) = self.dropped.iter_mut().find(|i| i.id == id) {
+                item.velocity = pulled(item.velocity);
+                hooked_item = true;
             }
-            damage = 5;
+            // CriteriaTriggers.FISHING_ROD_HOOKED with no items.
+            let hooked = self
+                .mobs
+                .iter()
+                .find(|m| m.id == id)
+                .map(|m| self.mob_entity(m));
+            if let Some(hooked) = hooked {
+                self.trigger_fishing_rod_hooked(rod, &hooked, &[]);
+            }
+            // `hookedIn instanceof ItemEntity ? 3 : 5`.
+            damage = if hooked_item { 3 } else { 5 };
         } else if hook.nibble > 0 {
             let biome = self.biome_name_at(hook.position);
             let Some(loot) = horizon_client::structure_blocks::loot_data(&self.options.resources)
             else {
                 return damage;
             };
+            // `withLuck(this.luck + owner.getLuck())`: the rod's Luck of the Sea
+            // plus the owner's luck attribute (the Luck and Bad Luck effects).
+            let owner_luck = self
+                .player
+                .as_mut()
+                .and_then(|p| p.attribute("minecraft:luck").ok())
+                .unwrap_or(0.0) as f32;
             let mut random = self.world.random.clone();
             let items = loot.roll(
                 "minecraft:gameplay/fishing",
                 &mut random,
-                hook.luck as f32,
+                hook.luck as f32 + owner_luck,
                 biome.as_deref(),
                 Some(hook.open_water),
             );
             self.world.random = random;
-            // FishingHook.retrieve: fish_caught for a catch.
-            self.stats.custom("fish_caught", 1);
+            let mut caught = Vec::new();
             for stack in items {
+                // FishingHook.retrieve: fish_caught for each catch in #minecraft:fishes.
+                if self
+                    .res
+                    .items()
+                    .item_tags
+                    .get("minecraft:fishes")
+                    .is_some_and(|t| t.contains(stack.item.as_str()))
+                {
+                    self.stats.custom("fish_caught", 1);
+                }
                 let mut item = ItemStack {
                     item: Arc::from(stack.item.as_str()),
                     count: stack.count.max(1) as u32,
@@ -205,6 +233,7 @@ impl Game<'_> {
                 if let Some(potion) = &stack.potion {
                     item = item.with_potion(potion);
                 }
+                caught.push(item.clone());
                 let (dx, dy, dz) = (
                     owner.x - hook.position.x,
                     owner.y - hook.position.y,
@@ -224,6 +253,15 @@ impl Game<'_> {
                 let xp = self.world.random.next_int_bound(6).unwrap_or(0) as u32 + 1;
                 self.spawn_orbs([owner.x, owner.y + 0.5, owner.z + 0.5], xp);
             }
+            // CriteriaTriggers.FISHING_ROD_HOOKED: the hook itself is the entity.
+            let bobber = EntityView {
+                kind: "minecraft:fishing_bobber".into(),
+                position: [hook.position.x, hook.position.y, hook.position.z],
+                on_ground: hook.on_ground,
+                fishing_open_water: Some(hook.open_water),
+                ..Default::default()
+            };
+            self.trigger_fishing_rod_hooked(rod, &bobber, &caught);
             damage = 1;
         }
         if hook.on_ground {
@@ -416,6 +454,8 @@ impl Game<'_> {
         let options = ParticleOptions::simple(kind);
         self.particles
             .send_particles(&options, at, spread, speed, count);
+        // The players a server serves are sent them too.
+        self.lan_send_particles(&options, at, spread, speed, count);
     }
     /// `FishingHook.tick`.
     pub(super) fn tick_fishing(&mut self) {
@@ -457,35 +497,47 @@ impl Game<'_> {
                     self.hook = Some(h);
                     return;
                 }
-                // checkCollision: hook the first living mob it touches.
+                // checkCollision: hook the first living mob it touches, or (via
+                // `canHitEntity`) a dropped item.
                 let bb = bounds(h.position);
                 let (lo, hi) = (bb.min_position(), bb.max_position());
-                if let Some(m) = self.mobs.iter().find(|m| {
-                    let mb = m.bounds();
-                    let (a, z) = (mb.min_position(), mb.max_position());
-                    m.alive()
-                        && a.x < hi.x
-                        && lo.x < z.x
-                        && a.y < hi.y
-                        && lo.y < z.y
-                        && a.z < hi.z
-                        && lo.z < z.z
-                }) {
-                    h.state = State::Hooked(m.id);
+                let touches = |b: Aabb| {
+                    let (a, z) = (b.min_position(), b.max_position());
+                    a.x < hi.x && lo.x < z.x && a.y < hi.y && lo.y < z.y && a.z < hi.z && lo.z < z.z
+                };
+                let hit = self
+                    .mobs
+                    .iter()
+                    .find(|m| m.alive() && touches(m.bounds()))
+                    .map(|m| m.id)
+                    .or_else(|| {
+                        self.dropped
+                            .iter()
+                            .find(|i| touches(i.bounds()))
+                            .map(|i| i.id)
+                    });
+                if let Some(id) = hit {
+                    h.state = State::Hooked(id);
                     h.velocity = Vec3::ZERO;
                     self.hook = Some(h);
                     return;
                 }
             }
             State::Hooked(id) => {
-                match self.mobs.iter().find(|m| m.id == id && m.alive()) {
-                    Some(m) => {
-                        h.position = Vec3::new(
-                            m.position.x,
-                            m.position.y + f64::from(m.height()) * 0.8,
-                            m.position.z,
-                        )
-                    }
+                // updateHookedEntity: ride the hooked mob or item at 0.8 of its height.
+                let hooked = self
+                    .mobs
+                    .iter()
+                    .find(|m| m.id == id && m.alive())
+                    .map(|m| (m.position, f64::from(m.height())))
+                    .or_else(|| {
+                        self.dropped
+                            .iter()
+                            .find(|i| i.id == id)
+                            .map(|i| (i.position, horizon_client::entities::ItemEntity::WIDTH))
+                    });
+                match hooked {
+                    Some((at, height)) => h.position = Vec3::new(at.x, at.y + height * 0.8, at.z),
                     None => h.state = State::Flying,
                 }
                 self.hook = Some(h);
@@ -614,6 +666,8 @@ impl Game<'_> {
                     layer: 0,
                     color: 0xFFFF_FFFF,
                     light: packed,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
@@ -741,8 +795,8 @@ impl Game<'_> {
 pub(super) struct RemoteHook {
     id: u32,
     owner: u32,
-    position: Vec3,
-    previous: Vec3,
+    pub(super) position: Vec3,
+    pub(super) previous: Vec3,
 }
 
 impl Hook {
diff --git a/crates/horizon-client/src/game/fov.rs b/crates/horizon-client/src/game/fov.rs
index 95e2e1e6e..364f89189 100644
--- a/crates/horizon-client/src/game/fov.rs
+++ b/crates/horizon-client/src/game/fov.rs
@@ -114,7 +114,7 @@ impl Game<'_> {
             living: Some(HurtBob {
                 hurt_time: p.health.hurt_animation_time as f32 - partial,
                 hurt_duration: hurt.hurt_duration,
-                hurt_dir: 0.0,
+                hurt_dir: p.health.hurt_dir,
                 death_time: self.death_time().map(|t| t as f32 + partial),
             }),
             player: Some((
diff --git a/crates/horizon-client/src/game/frames.rs b/crates/horizon-client/src/game/frames.rs
index d08c5f283..f4721ae26 100644
--- a/crates/horizon-client/src/game/frames.rs
+++ b/crates/horizon-client/src/game/frames.rs
@@ -311,8 +311,9 @@ impl Game<'_> {
         let sprites = &self.gui.atlas.sprites;
         let mut maps: Vec<(i32, glam::Mat4, u32)> = Vec::new();
         let mut items: Vec<(ItemStack, u32, glam::Mat4, u8)> = Vec::new();
-        // ItemFrame.shouldRenderAtSqrDistance: 1024 blocks at 100%.
-        let range = 16.0 * 64.0 * f64::from(self.settings.entity_distance);
+        // ItemFrame.shouldRenderAtSqrDistance: 1024 blocks at a view scale
+        // of 1.
+        let range = 16.0 * 64.0 * self.view_scale();
         for f in &self.item_frames {
             let entity_start = out.len();
             let map = f.item.as_ref().and_then(super::maps::map_id);
@@ -377,6 +378,8 @@ impl Game<'_> {
                             layer: 0,
                             color: 0xFFFF_FFFF,
                             light,
+
+                            glint_uv: [0.0, 0.0],
                         });
                     }
                 };
@@ -456,7 +459,7 @@ impl Game<'_> {
         }
         for (id, m, light) in maps {
             let entity_start = out.len();
-            self.map_vertices(id, m, light, out);
+            self.map_vertices(id, true, m, light, out);
             self.cull_entity_vertices(out, entity_start);
         }
     }
diff --git a/crates/horizon-client/src/game/glowing.rs b/crates/horizon-client/src/game/glowing.rs
new file mode 100644
index 000000000..8c78dbd77
--- /dev/null
+++ b/crates/horizon-client/src/game/glowing.rs
@@ -0,0 +1,53 @@
+//! Glowing entities (`EntityRenderer.extractRenderState`'s outlineColor): which entities
+//! appear glowing, in which team colour, and their silhouettes for the renderer's entity
+//! outline (`OutlineBufferSource`).
+use super::{Game, Vertex};
+use horizon_client::{mobs::Mob, scoreboard as sb};
+
+/// `Entity.getTeamColor`: the team's colour, else white.
+pub(super) fn team_color(team: Option<&sb::Team>) -> u32 {
+    team.and_then(|t| t.color.as_deref())
+        .and_then(sb::team_color_rgb)
+        .unwrap_or(0xFF_FFFF)
+}
+
+impl Game<'_> {
+    /// `Entity.isCurrentlyGlowing` of an entity that is not living (an item, a projectile):
+    /// its `Glowing` tag, or shared flag 6 as a server sent it.
+    pub(super) fn entity_glowing(&self, id: u32) -> bool {
+        self.remote_glowing(id).unwrap_or_else(|| {
+            self.persist_raw(id)
+                .and_then(|t| horizon_client::save::number(t.get("Glowing")))
+                .is_some_and(|b| b != 0)
+        })
+    }
+
+    /// `Minecraft.shouldEntityAppearGlowing` of a mob or another player, with its outline
+    /// colour (`getTeamColor`; another player's team goes by name).
+    pub(super) fn mob_outline(&self, m: &Mob) -> Option<u32> {
+        if !m.is_currently_glowing() {
+            return None;
+        }
+        let team = if &*m.kind.id == "minecraft:player" {
+            let names = self.remote_player_names();
+            let name = names.into_iter().find(|(id, _)| *id == m.id);
+            name.and_then(|(_, name)| self.score.board.players_team(&name))
+        } else {
+            self.mob_team(m.id)
+        };
+        Some(team_color(team))
+    }
+
+    /// Adds one glowing entity's geometry to the outline pass in `rgb`, the textures'
+    /// alpha kept (`OutlineBufferSource`'s team-coloured copy of each draw).
+    pub(super) fn mark_outline(&self, vertices: &[Vertex], rgb: u32) {
+        let color = horizon_client::mobs::render::abgr(rgb);
+        self.glowing_vertices
+            .borrow_mut()
+            .extend(vertices.iter().map(|v| Vertex {
+                color,
+                normal: [0; 4],
+                ..*v
+            }));
+    }
+}
diff --git a/crates/horizon-client/src/game/hand.rs b/crates/horizon-client/src/game/hand.rs
index d91d3b979..60869952f 100644
--- a/crates/horizon-client/src/game/hand.rs
+++ b/crates/horizon-client/src/game/hand.rs
@@ -3,7 +3,7 @@
 //! `continueAttack`, `MultiPlayerGameMode` block breaking), the arm swing
 //! (`LivingEntity.SwingState`) and the first-person equip heights
 //! (`FirstPersonHandsAndItems`) with the item swap ticker they read.
-use super::{Game, Mining, Screen};
+use super::{Game, Mining, Screen, minecarts::CartKind};
 use horizon_client::{
     Result,
     attack_strength::HeldStack,
@@ -289,6 +289,64 @@ impl Game<'_> {
         // Only alive mobs are hit, so a picked living entity is alive.
         Some(true)
     }
+    /// `Hud.canRenderCrosshairForSpectator` for the nearest hit in reach: an
+    /// entity that is a `MenuProvider` (a chest or hopper minecart, a chest
+    /// boat), or a block whose `showAsInteractableInSpectatorMode` holds.
+    pub(super) fn spectator_crosshair(&self) -> bool {
+        let cart = self.cart_hit().map(|(i, d)| {
+            let kind = &self.carts[i].kind;
+            (d, matches!(kind, CartKind::Chest | CartKind::Hopper))
+        });
+        let boat = self.boat_hit().map(|(i, d)| (d, self.boats[i].chest));
+        let others = [
+            self.mob_hit().map(|h| h.1),
+            self.armor_stand_hit().map(|h| h.1),
+            self.cushion_hit().map(|h| h.1),
+            self.painting_hit().map(|h| h.1),
+            self.frame_hit().map(|h| h.1),
+            self.dragon_hit().map(|h| h.1),
+        ];
+        let nearest = cart
+            .into_iter()
+            .chain(boat)
+            .chain(others.into_iter().flatten().map(|d| (d, false)))
+            .min_by(|a, b| a.0.total_cmp(&b.0));
+        if let Some((distance, menu)) = nearest
+            && self.before_block(distance)
+        {
+            return menu;
+        }
+        let Some(hit) = self.pick() else {
+            return false;
+        };
+        let name = &*self
+            .res
+            .facts()
+            .get(self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]))
+            .name;
+        let name = name.trim_start_matches("minecraft:");
+        match name {
+            // BlockBehaviour.getMenuProvider and `instanceof Portal`.
+            "crafting_table" | "enchanting_table" | "anvil" | "chipped_anvil" | "damaged_anvil"
+            | "stonecutter" | "loom" | "cartography_table" | "grindstone" | "smithing_table"
+            | "barrel" | "furnace" | "blast_furnace" | "smoker" | "brewing_stand" | "hopper"
+            | "dispenser" | "dropper" | "crafter" | "lectern" | "beacon" | "nether_portal"
+            | "end_portal" | "end_gateway" => true,
+            // ChestBlock.getMenuProvider: none while a redstone conductor
+            // sits on top of either half (a sitting cat aside).
+            "chest" | "trapped_chest" => {
+                let key = (hit.pos[0], hit.pos[1], hit.pos[2]);
+                let blocked = |p: (i32, i32, i32)| {
+                    let above = self.world.block(p.0, p.1 + 1, p.2);
+                    self.res.behaviours().facts(above).flags
+                        & horizon_world::level::data::state_flags::CONDUCTOR
+                        != 0
+                };
+                !blocked(key) && self.chest_other_half(key).is_none_or(|o| !blocked(o))
+            }
+            _ => name.ends_with("shulker_box"),
+        }
+    }
     /// `Attributes.ATTACK_SPEED` with the main-hand item's modifier.
     pub(super) fn main_hand_attack_speed(&self) -> f64 {
         horizon_client::attack_strength::BASE_ATTACK_SPEED
diff --git a/crates/horizon-client/src/game/initial_spawn.rs b/crates/horizon-client/src/game/initial_spawn.rs
index 3f7a071bb..c1149b26a 100644
--- a/crates/horizon-client/src/game/initial_spawn.rs
+++ b/crates/horizon-client/src/game/initial_spawn.rs
@@ -20,7 +20,8 @@ use horizon_core::{
 };
 use horizon_world::{
     block_collision::BlockCollisionRegistry, collision_context::CollisionContext,
-    heightmap::HeightmapType, worldgen::terrain::TerrainBlockStates,
+    heightmap::HeightmapType, level::flags::UPDATE_CLIENTS, registry::BlockStateId,
+    worldgen::terrain::TerrainBlockStates,
 };
 
 /// The loaded world as the spawn searches query it.
@@ -121,33 +122,102 @@ impl Game<'_> {
         }
         Ok(Some([ox * 16 + 8, height, oz * 16 + 8]))
     }
+    /// MinecraftServer.setInitialSpawn's bonus chest: BonusChestFeature.place
+    /// in the spawn chunk, a chest with the spawn bonus loot and a torch on
+    /// each side that can hold one, on the first free column of a shuffled
+    /// walk over the chunk. Skipped while the chunk is not loaded.
+    pub(super) fn place_bonus_chest(&mut self, origin: [i32; 3]) -> Result<()> {
+        use horizon_client::containers::BlockEntity;
+        let (cx, cz) = (origin[0] >> 4, origin[2] >> 4);
+        let registry = &self.pack.assets.registry;
+        let (Some(chest), Some(torch)) = (
+            registry.default_state("minecraft:chest"),
+            registry.default_state("minecraft:torch"),
+        ) else {
+            return Ok(());
+        };
+        if !self.streaming.is_lit(cx, cz) {
+            return Ok(());
+        }
+        // `level.getRandom()`. Util.toShuffledList of the chunk's x and z.
+        let random = &mut self.world.random;
+        let mut shuffled = |min: i32| -> [i32; 16] {
+            let mut values: [i32; 16] = std::array::from_fn(|i| min + i as i32);
+            for end in (2..=16usize).rev() {
+                let other = random.next_int_bound(end as i32).unwrap_or(0) as usize;
+                values.swap(end - 1, other);
+            }
+            values
+        };
+        let (xs, zs) = (shuffled(cx * 16), shuffled(cz * 16));
+        for x in xs {
+            for z in zs {
+                let y = self
+                    .spawn_columns()
+                    .height(HeightmapType::MotionBlockingNoLeaves, x, z);
+                if self.world.block(x, y, z) != self.world.air && !self.collision_empty([x, y, z]) {
+                    continue;
+                }
+                self.set_block_clients([x, y, z], chest)?;
+                let seed = self.world.random.next_long();
+                self.world
+                    .block_entities
+                    .insert((x, y, z), BlockEntity::Chest(Vec::new()));
+                self.load_block_entity_nbt(
+                    [x, y, z],
+                    &format!(
+                        "{{LootTable:\"minecraft:chests/spawn_bonus_chest\",LootTableSeed:{seed}L}}"
+                    ),
+                );
+                for [dx, dz] in [[0, -1], [1, 0], [0, 1], [-1, 0]] {
+                    let at = [x + dx, y, z + dz];
+                    let survives = self.with_level(|b, level, ticks| {
+                        b.can_survive(level, ticks, BlockPos::new(at[0], at[1], at[2]), torch)
+                    });
+                    if survives {
+                        self.set_block_clients(at, torch)?;
+                    }
+                }
+                return Ok(());
+            }
+        }
+        Ok(())
+    }
+    /// `Level.setBlock(pos, state, UPDATE_CLIENTS)`: no neighbour updates.
+    fn set_block_clients(&mut self, pos: [i32; 3], state: BlockStateId) -> Result<()> {
+        self.with_level(|b, level, ticks| {
+            b.set_block(
+                level,
+                ticks,
+                BlockPos::new(pos[0], pos[1], pos[2]),
+                state,
+                UPDATE_CLIENTS,
+            );
+        });
+        self.process_level_events()
+    }
+    /// The block at `pos` has no collision shape.
+    fn collision_empty(&self, pos: [i32; 3]) -> bool {
+        let mut scene = SceneCollisions {
+            world: &self.world,
+            binding: self.collision,
+            subject: None,
+        };
+        self.collision
+            .collision_shape_with_context(
+                &mut scene,
+                self.world.block(pos[0], pos[1], pos[2]),
+                BlockPos::new(pos[0], pos[1], pos[2]),
+                &CollisionContext::empty(false),
+            )
+            .is_ok_and(|shape| shape.is_empty())
+    }
     /// PlayerSpawnFinder.findSpawn around the world spawn: the feet of a
     /// player who has no position yet. None while a candidate's chunk loads.
     pub(super) fn find_player_spawn(&mut self, suggestion: [i32; 3]) -> Result<Option<Vec3>> {
         let mut finder = match self.player_spawn {
             Some(finder) => finder,
-            None if self.level.game_mode == 2 => {
-                // Adventure mode: the suggestion itself.
-                let mut finder = PlayerSpawnFinder::new(suggestion, 0, |_| 0);
-                finder.next_candidate();
-                finder
-            }
-            None => {
-                let mut radius = self.ui.rules.int("respawn_radius").max(0);
-                let to_border = self
-                    .border
-                    .distance(f64::from(suggestion[0]), f64::from(suggestion[2]))
-                    .floor() as i32;
-                if to_border < radius {
-                    radius = to_border;
-                }
-                if to_border <= 1 {
-                    radius = 1;
-                }
-                PlayerSpawnFinder::new(suggestion, radius, |n| {
-                    entity_random().next_int_bound(n).unwrap_or(0)
-                })
-            }
+            None => self.spawn_finder(suggestion),
         };
         let found = loop {
             let Some(candidate) = finder.next_candidate() else {
@@ -176,6 +246,58 @@ impl Game<'_> {
         self.player_spawn = found.is_none().then_some(finder);
         Ok(found)
     }
+    /// A new PlayerSpawnFinder around `suggestion`: the respawn radius, cut
+    /// by the world border; the suggestion itself in adventure mode.
+    fn spawn_finder(&self, suggestion: [i32; 3]) -> PlayerSpawnFinder {
+        if self.level.game_mode == 2 {
+            let mut finder = PlayerSpawnFinder::new(suggestion, 0, |_| 0);
+            finder.next_candidate();
+            return finder;
+        }
+        let mut radius = self.ui.rules.int("respawn_radius").max(0);
+        let to_border = self
+            .border
+            .distance(f64::from(suggestion[0]), f64::from(suggestion[2]))
+            .floor() as i32;
+        if to_border < radius {
+            radius = to_border;
+        }
+        if to_border <= 1 {
+            radius = 1;
+        }
+        PlayerSpawnFinder::new(suggestion, radius, |n| {
+            entity_random().next_int_bound(n).unwrap_or(0)
+        })
+    }
+    /// ServerPlayer.adjustSpawnLocation for a server's new player: where
+    /// PlayerSpawnFinder.findSpawn puts their feet around the world spawn
+    /// (`spawn`, the feet there), so that players new to a world don't all
+    /// stand in one spot. Vanilla waits for each candidate's chunk; a server
+    /// tick can't, so a candidate in a chunk not loaded yet is passed over,
+    /// and `spawn` stays when the search never reaches a loaded column.
+    pub(super) fn server_player_spawn(&self, spawn: [f64; 3]) -> [f64; 3] {
+        let suggestion = spawn.map(|v| v.floor() as i32);
+        let mut finder = self.spawn_finder(suggestion);
+        while let Some(candidate) = finder.next_candidate() {
+            let (x, z) = match candidate {
+                SpawnCandidate::Column(x, z) => (x, z),
+                SpawnCandidate::Suggestion => (suggestion[0], suggestion[2]),
+            };
+            if !self.streaming.is_lit(x >> 4, z >> 4) {
+                continue;
+            }
+            let feet = match candidate {
+                SpawnCandidate::Column(x, z) => level_respawn_pos(&self.spawn_columns(), x, z)
+                    .filter(|&pos| self.player_fits(pos))
+                    .map(bottom_center),
+                SpawnCandidate::Suggestion => Some(self.fixup_spawn_height(suggestion)),
+            };
+            if let Some(feet) = feet {
+                return [feet.x, feet.y, feet.z];
+            }
+        }
+        spawn
+    }
     /// PlayerSpawnFinder.noCollisionNoLiquid: a player's box standing at the
     /// block's bottom centre touches no block or liquid.
     fn player_fits(&self, pos: [i32; 3]) -> bool {
diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs
index dd1c04e23..df40ff377 100644
--- a/crates/horizon-client/src/game/integrated.rs
+++ b/crates/horizon-client/src/game/integrated.rs
@@ -52,6 +52,8 @@ struct Flags {
     /// server follows while it runs (IntegratedServer.tickServer).
     render_distance: AtomicI32,
     simulation_distance: AtomicI32,
+    /// `MinecraftServer.isCurrentlySaving`: the server is autosaving.
+    saving: AtomicBool,
 }
 
 /// Work the window hands its server thread (`MinecraftServer.execute`).
@@ -69,6 +71,10 @@ impl Integrated {
     pub fn smoothed_tick_ms(&self) -> f32 {
         f32::from_bits(self.flags.smoothed_tick_ms.load(Ordering::Relaxed))
     }
+    /// `MinecraftServer.isCurrentlySaving`.
+    pub fn is_saving(&self) -> bool {
+        self.flags.saving.load(Ordering::Relaxed)
+    }
     /// `IntegratedServer.tickServer` skips the world while the game is paused.
     pub fn set_paused(&self, paused: bool) {
         self.flags.paused.store(paused, Ordering::Relaxed);
@@ -148,6 +154,12 @@ pub(super) struct Serving {
     /// is out of its place: applied after the tick.
     pending: Option<Publish>,
 }
+impl Serving {
+    /// The window reads this as `MinecraftServer.isCurrentlySaving`.
+    pub(super) fn set_saving(&self, saving: bool) {
+        self.flags.saving.store(saving, Ordering::Relaxed);
+    }
+}
 enum Publish {
     Open(TcpListener, LanSettings),
     Close,
@@ -408,6 +420,8 @@ impl Game<'_> {
             s.flags.published.store(0, Ordering::Relaxed);
         }
         if let Some(mut host) = self.lan.take() {
+            // PlayerList.removeAll: the owner and every guest leave the game.
+            host.award_leave_game_to_all();
             for g in &host.hub.guests {
                 self.save_guest(&host, g);
             }
diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs
index b6b7e2fb7..efb83e5db 100644
--- a/crates/horizon-client/src/game/item_draw.rs
+++ b/crates/horizon-client/src/game/item_draw.rs
@@ -129,6 +129,7 @@ pub(super) struct Host<'a> {
     banners: &'a horizon_client::banner::Banners,
     sprites: &'a HashMap<String, Rect>,
     skins: &'a RefCell<horizon_client::skins::Downloader>,
+    profiles: &'a RefCell<horizon_client::skins::Resolver>,
 }
 impl SpecialHost for Host<'_> {
     fn banner_texture(&self, pattern: &str) -> Option<String> {
@@ -144,14 +145,14 @@ impl SpecialHost for Host<'_> {
     fn player_skin(&self, profile: &Value) -> Option<String> {
         // SkullBlockRenderer.getPlayerSkin: SkinManager.getInsecureSkinInformation
         // accepts a texture property without a signature, unlike the tab list.
-        let url = horizon_client::skins::profile_skin_url(profile)?;
-        let location =
-            horizon_client::skins::skin_location(&horizon_client::skins::texture_hash(&url)?);
-        let _ = self
-            .skins
-            .borrow_mut()
-            .state(horizon_client::skins::Kind::Skin, &url);
-        self.sprites.contains_key(&location).then_some(location)
+        // A `Dynamic` profile (a name or id only) resolves through the
+        // services (`PlayerSkinRenderCache.getOrDefault`).
+        Some(horizon_client::skins::head_skin(
+            profile,
+            &mut self.profiles.borrow_mut(),
+            &mut self.skins.borrow_mut(),
+            |location| self.sprites.contains_key(location),
+        ))
     }
 }
 
@@ -194,6 +195,7 @@ impl Game<'_> {
             banners: &self.res.stations().banners,
             sprites: &self.gui.atlas.sprites,
             skins: &self.skin_downloads,
+            profiles: &self.skin_profiles,
         }
     }
     /// The client level as item models read it: worked out once a frame (a
@@ -296,8 +298,32 @@ impl Game<'_> {
             x,
             y,
             self.started.elapsed().as_secs_f32(),
+            self.settings.file.double("glintSpeed") as f32,
+            self.settings.file.double("glintStrength") as f32,
         );
     }
+    /// The `GLINT_TEXTURING` inputs the atlas and options provide.
+    pub(super) fn glint(&self) -> Option<item_render::Glint> {
+        self.gui
+            .atlas
+            .sprites
+            .get("misc/enchanted_glint_item")
+            .copied()
+            .map(|_| item_render::Glint {
+                speed: self.settings.file.double("glintSpeed") as f32,
+                alpha: self.settings.file.double("glintStrength") as f32,
+                millis: self.started.elapsed().as_secs_f32() * 1000.0,
+                scale: 0.5,
+            })
+    }
+    /// The glint scroll phase shared by world items and armour
+    /// (`item_render::Glint::scroll_ticks`).
+    pub(super) fn glint_ticks(&self) -> f32 {
+        item_render::Glint::scroll_ticks(
+            self.started.elapsed().as_secs_f32() * 1000.0,
+            self.settings.file.double("glintSpeed") as f32,
+        )
+    }
     /// Submit a resolved item under `pose` (camera-relative) at `light`
     /// (packed lightmap coordinates).
     pub(super) fn submit_item_world(
@@ -311,6 +337,7 @@ impl Game<'_> {
             out,
             light,
             lights: Some(diffuse_lights(self.dim == Dim::Nether)),
+            glint: self.glint(),
         };
         state.submit(
             &self.pack.item_renderer,
@@ -332,6 +359,7 @@ impl Game<'_> {
             out,
             light,
             lights: None,
+            glint: self.glint(),
         };
         state.submit(
             &self.pack.item_renderer,
@@ -405,7 +433,12 @@ impl Game<'_> {
             ) {
                 self.submit_item_world(&state, copy, vertex_light(packed), out);
             }
-            self.cull_entity_vertices(out, entity_start);
+            if self.entity_glowing(item.id) {
+                let rgb = super::glowing::team_color(self.mob_team(item.id));
+                self.mark_outline(&out[entity_start..], rgb);
+            } else {
+                self.cull_entity_vertices(out, entity_start);
+            }
         }
     }
 }
diff --git a/crates/horizon-client/src/game/jukebox.rs b/crates/horizon-client/src/game/jukebox.rs
index c3ed75ebb..87f91895e 100644
--- a/crates/horizon-client/src/game/jukebox.rs
+++ b/crates/horizon-client/src/game/jukebox.rs
@@ -79,6 +79,7 @@ impl Game<'_> {
         if !self.creative {
             self.consume_held();
         }
+        self.stats.custom("play_record", 1);
         self.world.block_entities.insert(
             (pos[0], pos[1], pos[2]),
             BlockEntity::Jukebox(Jukebox {
@@ -90,6 +91,8 @@ impl Game<'_> {
         self.set_has_record(pos, true);
         self.start_song(pos, &song);
         self.jukebox_changed(pos);
+        // ServerPlayerGameMode.useItemOn: the action was consumed.
+        self.trigger_block("minecraft:item_used_on_block", pos, stack);
         true
     }
     /// Level event 1010: the song from the jukebox, and the "Now Playing" overlay.
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index 5292cd31b..506c6c419 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -11,7 +11,7 @@ use horizon_client::{
         chunks::ChunkEncoder,
         data::SyncData,
         entity::{EntityState, States},
-        hub::{HostEvent, HostState, Hub, HubConfig, TickCtx},
+        hub::{BodyFlags, HostEvent, HostState, Hub, HubConfig, TickCtx},
         playerdata,
     },
     mobs::{Mob, Who, leash::Holder},
@@ -21,14 +21,28 @@ use horizon_core::geometry::Vec3;
 use horizon_protocol::{
     crypto::offline_uuid,
     entity_data::{Value, serializer},
+    packets::play::{self, Clientbound as C},
 };
 use std::{
     collections::HashMap,
-    sync::{Arc, OnceLock},
+    sync::{Arc, Mutex},
 };
 
 /// The registries and tags are the same for every world: load them once.
-static SYNC: OnceLock<std::result::Result<Arc<SyncData>, String>> = OnceLock::new();
+static SYNC: Mutex<Option<std::result::Result<Arc<SyncData>, String>>> = Mutex::new(None);
+
+/// The registries and tags a server sends, loaded from `root` the first time.
+pub(super) fn sync_data(root: &std::path::Path) -> std::result::Result<Arc<SyncData>, String> {
+    let mut sync = SYNC.lock().unwrap_or_else(|e| e.into_inner());
+    sync.get_or_insert_with(|| SyncData::load(root).map(Arc::new))
+        .clone()
+}
+
+/// Let go of what `sync_data` loaded: for a preload no world used
+/// (game/world_loading.rs).
+pub(super) fn forget_sync_data() {
+    *SYNC.lock().unwrap_or_else(|e| e.into_inner()) = None;
+}
 
 /// The settings of the open world (WorldOptionsScreen's multiplayer section).
 #[derive(Clone, Copy, Debug)]
@@ -78,6 +92,33 @@ pub(super) struct LanHost {
     states: lan::entity::States,
 }
 
+impl LanHost {
+    /// `PlayerList.remove`: `player.awardStat(Stats.LEAVE_GAME)` before the
+    /// player is saved. Once per guest, however often they are saved.
+    pub(super) fn award_leave_game(&mut self, conn: u32) {
+        if let Some(play) = self.play.get_mut(&conn)
+            && !play.left_game
+        {
+            play.left_game = true;
+            play.stats.custom("leave_game", 1);
+        }
+    }
+
+    /// `PlayerList.removeAll`: every player who joined leaves with the world.
+    pub(super) fn award_leave_game_to_all(&mut self) {
+        let conns: Vec<u32> = self
+            .hub
+            .guests
+            .iter()
+            .filter(|g| g.placed)
+            .map(|g| g.conn)
+            .collect();
+        for conn in conns {
+            self.award_leave_game(conn);
+        }
+    }
+}
+
 /// The player who owns an integrated server's world: a guest whose state is
 /// the world's own player (`players/data/<singleplayer_uuid>.dat`), as in
 /// single player.
@@ -148,12 +189,22 @@ fn mob_meta(
     m: &Mob,
     hub: &Hub,
     player_entity: Option<i32>,
+    game_time: i64,
     meta: &mut Vec<(u8, i32, Value)>,
     defaults: &mut Vec<(u8, i32, Value)>,
 ) {
     let kind = m.kind.id.as_str();
-    if m.fire_ticks > 0 {
-        meta.push((0, serializer::BYTE, Value::Byte(1)));
+    // Entity.DATA_SHARED_FLAGS_ID: on fire 0x01, glowing 0x40
+    // (LivingEntity.updateGlowingStatus).
+    let shared = i8::from(m.fire_ticks > 0) | i8::from(m.is_currently_glowing()) << 6;
+    if shared != 0 {
+        meta.push((0, serializer::BYTE, Value::Byte(shared)));
+    }
+    // Entity.DATA_POSE: the pose the species keeps in its own fields (a
+    // pose back at standing goes out by the entity's own default).
+    let pose = horizon_client::mobs::sync::pose_id(m);
+    if pose != 0 {
+        meta.push((6, serializer::POSE, Value::Id(i32::from(pose))));
     }
     if let Some(name) = &m.custom_name {
         meta.push((
@@ -178,6 +229,17 @@ fn mob_meta(
         meta.push((9, serializer::FLOAT, Value::Float(health)));
     }
     defaults.push((9, serializer::FLOAT, Value::Float(1.0)));
+    // LivingEntity.DATA_EFFECT_PARTICLES and DATA_EFFECT_AMBIENCE_ID: the
+    // swirls of its effects (the ones a mob has are visible, not ambient).
+    meta.extend(
+        hub.effect_meta(
+            (m.extra.effects.iter())
+                .filter(|e| !m.extra.hidden_effects.contains(&e.0))
+                .map(|e| (e.0, false)),
+        ),
+    );
+    defaults.push((10, serializer::PARTICLES, Value::Particles(Vec::new())));
+    defaults.push((11, serializer::BOOLEAN, Value::Bool(false)));
     // Mob.DATA_MOB_FLAGS_ID: no AI 1, left-handed 2, aggressive 4 (what
     // draws a vindicator's axe, a skeleton's drawn bow, a piglin's raised
     // weapon).
@@ -223,6 +285,27 @@ fn mob_meta(
             }
             defaults.push((16, serializer::BYTE, Value::Byte(0)));
         }
+        // SnowGolem.DATA_PUMPKIN_ID: 16 while the pumpkin is on (the default).
+        "minecraft:snow_golem" => {
+            if e.sheared {
+                meta.push((16, serializer::BYTE, Value::Byte(0)));
+            }
+            defaults.push((16, serializer::BYTE, Value::Byte(16)));
+        }
+        // MushroomCow.DATA_TYPE: 0 red, 1 brown.
+        "minecraft:mooshroom" => {
+            if e.variant == 1 {
+                meta.push((17, serializer::INT, Value::Int(1)));
+            }
+            defaults.push((17, serializer::INT, Value::Int(0)));
+        }
+        // Piglin.DATA_IS_DANCING (after the baby flag and the crossbow charge).
+        "minecraft:piglin" => {
+            if e.scratch[0] > 0 {
+                meta.push((19, serializer::BOOLEAN, Value::Bool(true)));
+            }
+            defaults.push((19, serializer::BOOLEAN, Value::Bool(false)));
+        }
         // Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 when sheared.
         "minecraft:sheep" => {
             let value = (e.color & 15) | if e.sheared { 16 } else { 0 };
@@ -337,6 +420,14 @@ fn mob_meta(
             }
             defaults.push((17, serializer::BOOLEAN, Value::Bool(false)));
         }
+        // PolarBear.DATA_STANDING_ID (after AgeableMob's two): the bear
+        // rears up; the client animates it.
+        "minecraft:polar_bear" => {
+            if e.flag {
+                meta.push((18, serializer::BOOLEAN, Value::Bool(true)));
+            }
+            defaults.push((18, serializer::BOOLEAN, Value::Bool(false)));
+        }
         // SpellcasterIllager.DATA_SPELL_CASTING_ID: the casting pose.
         "minecraft:evoker" | "minecraft:illusioner" => {
             if e.variant2 != 0 {
@@ -344,6 +435,41 @@ fn mob_meta(
             }
             defaults.push((17, serializer::BYTE, Value::Byte(0)));
         }
+        // Warden.CLIENT_ANGER_LEVEL: the heartbeat's pace.
+        "minecraft:warden" => {
+            let anger = e.warden.as_ref().map_or(0, |w| w.client_anger);
+            if anger != 0 {
+                meta.push((16, serializer::INT, Value::Int(anger)));
+            }
+            defaults.push((16, serializer::INT, Value::Int(0)));
+        }
+        // Sniffer.DATA_STATE (after AgeableMob's two).
+        "minecraft:sniffer" => {
+            if e.variant != 0 {
+                meta.push((
+                    18,
+                    serializer::SNIFFER_STATE,
+                    Value::Id(i32::from(e.variant)),
+                ));
+            }
+            defaults.push((18, serializer::SNIFFER_STATE, Value::Id(0)));
+        }
+        // Shulker.DATA_ATTACH_FACE_ID, DATA_PEEK_ID and DATA_COLOR_ID (16
+        // for none).
+        "minecraft:shulker" => {
+            if e.variant3 != 0 {
+                meta.push((16, serializer::DIRECTION, Value::Id(i32::from(e.variant3))));
+            }
+            defaults.push((16, serializer::DIRECTION, Value::Id(0)));
+            if e.counter != 0 {
+                meta.push((17, serializer::BYTE, Value::Byte(e.counter as i8)));
+            }
+            defaults.push((17, serializer::BYTE, Value::Byte(0)));
+            if e.color != 16 {
+                meta.push((18, serializer::BYTE, Value::Byte(e.color as i8)));
+            }
+            defaults.push((18, serializer::BYTE, Value::Byte(16)));
+        }
         // Enderman.DATA_CARRY_STATE.
         "minecraft:enderman" => {
             if let Some(state) = e.carried {
@@ -356,6 +482,38 @@ fn mob_meta(
         }
         _ => {}
     }
+    // Camel.DASH and LAST_POSE_CHANGE_TICK (after AbstractHorse's flags).
+    if horizon_client::mobs::camel::is_camel(m.species()) {
+        if e.flag2 {
+            meta.push((19, serializer::BOOLEAN, Value::Bool(true)));
+        }
+        defaults.push((19, serializer::BOOLEAN, Value::Bool(false)));
+        let tick = horizon_client::mobs::camel::synced_pose_tick(m, game_time);
+        if tick != 0 {
+            meta.push((20, serializer::LONG, Value::Long(tick)));
+        }
+        defaults.push((20, serializer::LONG, Value::Long(0)));
+    }
+}
+
+/// What a client shakes a mob by: Entity.DATA_TICKS_FROZEN (7), whose full
+/// count is `isFullyFrozen`, and Strider.DATA_SUFFOCATING (19, after
+/// AgeableMob's two and DATA_BOOST_TIME).
+fn mob_freeze_meta(
+    m: &Mob,
+    meta: &mut Vec<(u8, i32, Value)>,
+    defaults: &mut Vec<(u8, i32, Value)>,
+) {
+    if m.ticks_frozen > 0 {
+        meta.push((7, serializer::INT, Value::Int(m.ticks_frozen)));
+    }
+    defaults.push((7, serializer::INT, Value::Int(0)));
+    if m.kind.id == "minecraft:strider" {
+        if m.extra.flag {
+            meta.push((19, serializer::BOOLEAN, Value::Bool(true)));
+        }
+        defaults.push((19, serializer::BOOLEAN, Value::Bool(false)));
+    }
 }
 
 /// The equipment a mob shows (ClientboundSetEquipmentPacket slots: main hand,
@@ -366,13 +524,16 @@ fn mob_equipment(
     out: &mut Vec<(u8, Option<horizon_protocol::item::Stack>)>,
 ) {
     let e = &m.extra;
+    // A horse's armour, a llama's carpet, a harness: Horizon keeps the body
+    // slot's item (6) in `head`.
+    let body = horizon_client::mobs::drops::head_is_body(m.species());
     let slots = [
         (0u8, &e.main_hand),
         (1, &e.off_hand),
         (2, &e.feet),
         (3, &e.legs),
         (4, &e.chest),
-        (5, &e.head),
+        (if body { 6 } else { 5 }, &e.head),
     ];
     for (slot, item) in slots {
         if let Some(item) = item {
@@ -562,10 +723,7 @@ impl Game<'_> {
         config: HubConfig,
         host: Option<u128>,
     ) -> Result<()> {
-        let root = self.options.resources.clone();
-        let sync = SYNC
-            .get_or_init(|| SyncData::load(&root).map(Arc::new))
-            .clone()?;
+        let sync = sync_data(&self.options.resources)?;
         let biome_names: Vec<String> = self
             .res
             .biomes()
@@ -654,6 +812,7 @@ impl Game<'_> {
         let Some(mut host) = self.lan.take() else {
             return;
         };
+        host.award_leave_game_to_all();
         for g in &host.hub.guests {
             self.save_guest(&host, g);
         }
@@ -665,6 +824,7 @@ impl Game<'_> {
         self.audio.capture = None;
         self.lan_events.clear();
         self.lan_critical_hits.clear();
+        self.lan_cushion_breaks.clear();
         self.streaming.extra.clear();
         if announce {
             self.system_message(Text::translate(
@@ -835,6 +995,16 @@ impl Game<'_> {
             living_flags: living_flags(self.using)
                 | if p.auto_spin_attack_ticks > 0 { 4 } else { 0 },
             bed: self.sleeping,
+            body: BodyFlags {
+                gliding: p.fall_flying,
+                swimming: p.swimming,
+                crawling: p.pose == horizon_client::pose::Pose::Swimming && !p.swimming,
+                crouching: p.pose == horizon_client::pose::Pose::Crouching,
+                spin_attack: p.auto_spin_attack_ticks > 0,
+                on_fire: p.fire_ticks > 0,
+                invisible: self.potions.effects.get("invisibility").is_some(),
+                glowing: self.potions.effects.get("glowing").is_some(),
+            },
         })
     }
 
@@ -850,7 +1020,7 @@ impl Game<'_> {
         out.clear();
         for m in self.mobs.iter().filter(|m| !m.removed) {
             // The lead's holder: the player the mob sees (a guest, else the
-            // host) or another mob. A fence knot isn't an entity here.
+            // host), another mob or a fence knot (game/lan_entities.rs).
             let player_entity = mob_players
                 .get(&m.id)
                 .and_then(|conn| hub.guest(*conn))
@@ -859,7 +1029,7 @@ impl Game<'_> {
             let leash = m.extra.leash.and_then(|h| match h {
                 Holder::Player => player_entity,
                 Holder::Mob(id) => Some(id as i32),
-                Holder::Knot(_) => None,
+                Holder::Knot(p) => self.knot_ids.get(&p).map(|&id| id as i32),
             });
             let e = out.add(m.id as i32, entity_uuid(m.id), m.kind.id.as_str());
             e.position = [m.position.x, m.position.y, m.position.z];
@@ -867,7 +1037,15 @@ impl Game<'_> {
             e.on_ground = m.on_ground;
             e.velocity = [m.velocity.x, m.velocity.y, m.velocity.z];
             e.needs_sync = m.needs_sync;
-            mob_meta(m, hub, player_entity, &mut e.meta, &mut e.defaults);
+            mob_meta(
+                m,
+                hub,
+                player_entity,
+                self.world.game_time,
+                &mut e.meta,
+                &mut e.defaults,
+            );
+            mob_freeze_meta(m, &mut e.meta, &mut e.defaults);
             mob_equipment(m, hub, &mut e.equipment);
             self.mob_attributes(m, &mut e.attributes);
             e.leash = leash;
@@ -878,6 +1056,10 @@ impl Game<'_> {
             e.position = [d.position.x, d.position.y, d.position.z];
             e.on_ground = d.on_ground;
             e.velocity = [d.velocity.x, d.velocity.y, d.velocity.z];
+            // Entity.DATA_SHARED_FLAGS_ID: glowing 0x40 (the Glowing tag).
+            if self.entity_glowing(d.id) {
+                e.meta.push((0, serializer::BYTE, Value::Byte(0x40)));
+            }
             e.meta.push((8, serializer::ITEM_STACK, Value::Item(stack)));
         }
         for o in &self.orbs {
@@ -944,6 +1126,9 @@ impl Game<'_> {
             for m in &mut self.mobs {
                 m.needs_sync = false;
             }
+            for p in &mut self.creatures.projectiles {
+                p.needs_sync = false;
+            }
             // `runBlockEvents`' broadcast precedes the tick's block changes
             // (`ChunkHolder.broadcastChanges` in `tick_level` below): the
             // guest re-runs a piston's `triggerEvent` while its level still
@@ -952,6 +1137,16 @@ impl Game<'_> {
                 host.hub.block_event(pos, b0, b1, state);
             }
             let entities = states.as_slice();
+            // An entity that left the level since the last tick (a snowball
+            // that hit) is dropped by the tracker below: its event goes out
+            // first, as `Level.broadcastEntityEvent` precedes the discard.
+            let (gone, later): (Vec<_>, Vec<_>) = std::mem::take(&mut self.lan_entity_events)
+                .into_iter()
+                .partition(|(id, ..)| !entities.iter().any(|e| e.id == *id));
+            self.lan_entity_events = later;
+            for (id, event, at) in gone {
+                host.hub.entity_event(id, event, at);
+            }
             let spawn = self.spawn.map_or([0.5, 80.0, 0.5], |s| [s.x, s.y, s.z]);
             let events = {
                 let clock_rate = self.network_clock_rate();
@@ -974,6 +1169,8 @@ impl Game<'_> {
                     self.ui.rules.bool("player_movement_check"),
                     self.ui.rules.bool("elytra_movement_check"),
                 );
+                host.hub
+                    .set_immediate_respawn(self.ui.rules.bool("immediate_respawn"));
                 // A server with several levels runs a pass for each
                 // (`tick_server`): the network is read once, before the first.
                 let pass = self.level_pass;
@@ -1044,6 +1241,9 @@ impl Game<'_> {
                             }
                         }
                         self.lan_crafting_left(&mut host, &mut guest);
+                        if guest.placed {
+                            host.award_leave_game(guest.conn);
+                        }
                         self.save_guest(&host, &guest);
                         host.models.remove(&guest.conn);
                         host.play.remove(&guest.conn);
@@ -1094,8 +1294,11 @@ impl Game<'_> {
         drop(holding);
         lan::flush_all(host.hub.guests.iter().map(|g| &g.sender));
         self.lan = Some(host);
-        // A mace's wind burst from a guest's attack.
+        // A blast from a guest's attack, and a mace's wind burst.
+        self.flush_lan_explosions();
         let _ = self.flush_wind_bursts();
+        // Particles a guest's turn sent (sweep attack, damage indicator, a hook's splashes).
+        self.flush_lan_particles();
     }
 
     fn lan_guest_joined(
@@ -1128,8 +1331,17 @@ impl Game<'_> {
             g.game_mode = default_mode;
         }
         if !known {
-            g.position = spawn;
-            g.previous_position = spawn;
+            // ServerPlayer.adjustSpawnLocation: a player new to the world
+            // stands where PlayerSpawnFinder puts them, not all on one spot
+            // (it reads the loaded level, which holds the spawn when it is
+            // the overworld).
+            let feet = if self.dim == super::Dim::Overworld {
+                self.server_player_spawn(spawn)
+            } else {
+                spawn
+            };
+            g.position = feet;
+            g.previous_position = feet;
             g.health = 20.0;
             g.food = 20;
             g.dimension = super::Dim::Overworld.id().to_owned();
@@ -1188,8 +1400,9 @@ impl Game<'_> {
                 horizon_world::level::LevelEvent::LevelEvent { id, pos, data } => {
                     // The acting guest does not predict the egg's teleport
                     // particles, bone meal's growth, or anvil result sounds
-                    // (these levelEvent calls name no excluded player).
-                    let except = if matches!(*id, 2015 | 1505 | 1029 | 1030) {
+                    // (these levelEvent calls name no excluded player), nor
+                    // the digger's own crack and hit sound (2019, 2020).
+                    let except = if matches!(*id, 2015 | 1505 | 1029 | 1030 | 2019 | 2020) {
                         None
                     } else {
                         self.lan_acting
@@ -1224,8 +1437,9 @@ impl Game<'_> {
             self.lan_entity_events.push((id, event, at));
         }
     }
-    /// `ServerPlayer.crit`: this window's emitter, and an animation for the
-    /// attacker's client and observers once the hub is back in place.
+    /// `ServerPlayer.crit` (or `magicCrit` when `magic`): this window's
+    /// emitter, and an animation for the attacker's client and observers once
+    /// the hub is back in place.
     pub(super) fn critical_hit(
         &mut self,
         attacker: Option<u32>,
@@ -1233,21 +1447,50 @@ impl Game<'_> {
         feet: [f64; 3],
         width: f64,
         height: f64,
+        magic: bool,
     ) {
         use horizon_client::particles::{ParticleOptions, ParticleType};
-        self.particles.tracking_emitter(
-            ParticleOptions::simple(ParticleType::Crit),
-            feet,
-            width,
-            height,
-        );
+        let particle = if magic {
+            ParticleType::EnchantedHit
+        } else {
+            ParticleType::Crit
+        };
+        self.particles
+            .tracking_emitter(ParticleOptions::simple(particle), feet, width, height);
         if self.audio.capture.is_some() {
-            self.lan_critical_hits.push((attacker, id));
+            self.lan_critical_hits.push((attacker, id, magic));
         }
     }
     /// Send the tick's level events, sounds and mob animations.
     fn lan_flush_effects(&mut self, host: &mut LanHost) {
         let critical_hits = std::mem::take(&mut self.lan_critical_hits);
+        for (state, at) in std::mem::take(&mut self.lan_cushion_breaks) {
+            if let Some(id) = host
+                .hub
+                .registry_id("minecraft:particle_type", "minecraft:block")
+            {
+                host.hub.broadcast_near(
+                    at,
+                    32.0,
+                    &C::LevelParticles(play::LevelParticles {
+                        particle: horizon_protocol::entity_data::Particle {
+                            id,
+                            data: Some(horizon_protocol::entity_data::ParticleData::State(
+                                state.0 as i32,
+                            )),
+                        },
+                        override_limiter: false,
+                        always_show: false,
+                        pos: at,
+                        dist: [0.25, 0.0625, 0.25],
+                        max_speed: [0.05; 3],
+                        count: 10,
+                        randomization: 0,
+                    }),
+                    None,
+                );
+            }
+        }
         for (kind, pos, data, acting) in std::mem::take(&mut self.lan_events) {
             if kind == 2001 {
                 host.broken
@@ -1320,13 +1563,13 @@ impl Game<'_> {
             seen.insert(m.id, (m.hurt_time, dead, swing));
         }
         host.mob_state.insert(self.dim, seen);
-        for (attacker, target) in critical_hits {
+        for (attacker, target, magic) in critical_hits {
             let Some(attacker) = attacker.map_or(Some(host.host_entity), |conn| {
                 host.hub.guest(conn).map(|g| g.entity_id)
             }) else {
                 continue;
             };
-            host.hub.critical_hit(attacker, target);
+            host.hub.critical_hit(attacker, target, magic);
         }
     }
 
@@ -1409,6 +1652,14 @@ impl Game<'_> {
                 .each_ref()
                 .map(|s| s.as_ref().map(|s| s.item.clone()));
             m.extra.crouching = g.sneaking;
+            m.extra.avatar_pose = g.pose();
+            m.extra.sprinting = g.sprinting;
+            // LivingEntity.DATA_EFFECT_PARTICLES: the swirls of its visible effects.
+            let visible = || g.effects.list.iter().filter(|e| e.visible);
+            m.extra.effect_particles = visible()
+                .filter_map(|e| super::client_ambient::effect_particle(e.id, e.ambient))
+                .collect();
+            m.extra.effect_ambient = visible().all(|e| e.ambient);
             // Lying in its bed (LivingEntity.getBedOrientation).
             m.extra.ints[1] = g.bed.map_or(0, |b| self.bed_facing(b));
             // LivingEntity.updateSwingTime: the arm swing lan_swings started.
@@ -1470,7 +1721,12 @@ impl Game<'_> {
                 out,
             );
             self.held_item_geometry(m, camera, alpha, packed, true, out);
-            if !m.glowing {
+            // LivingEntity.isCurrentlyGlowing: the guest's Glowing effect.
+            let guest = host.hub.guest(*conn);
+            if m.glowing || guest.is_some_and(|g| g.effects.get("glowing").is_some()) {
+                let team = guest.and_then(|g| self.score.board.players_team(&g.name));
+                self.mark_outline(&out[entity_start..], super::glowing::team_color(team));
+            } else {
                 self.cull_entity_vertices(out, entity_start);
             }
         }
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 43bb573dc..dde9b590d 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -74,7 +74,12 @@ pub(super) struct GuestPlay {
     potions: super::potions::BodyPotions,
     /// `ServerPlayer.getStats` and the inventory `inventory_changed` last saw.
     pub(super) stats: super::stats::Stats,
+    /// `Stats.LEAVE_GAME` is counted: a guest is saved more than once on the
+    /// way out, the statistic is awarded once (`LanHost::award_leave_game`).
+    pub(super) left_game: bool,
     last_inventory: u64,
+    /// `ServerPlayer.levitationStartPos` and `levitationStartTime`.
+    levitation: Option<([f64; 3], u64)>,
     /// `Entity.portalProcess` and `portalCooldown` (game/server_travel.rs).
     pub(super) portal: horizon_client::nether_portal::PortalState,
     /// `ServerPlayer.wonGame`: the End poem is showing, the player waits for
@@ -158,6 +163,7 @@ pub(super) struct GuestSwap {
     host_ender: Option<(i32, i32, i32)>,
     adv_loaded: bool,
     last_inventory: u64,
+    levitation: Option<([f64; 3], u64)>,
     death_cause: Option<String>,
     /// The guest's own damage record, in place while they act.
     combat: super::combat::CombatTracker,
@@ -165,6 +171,8 @@ pub(super) struct GuestSwap {
     acting: (Option<u32>, Option<String>, Option<u128>),
     /// The packets queued for that guest.
     packets: Vec<play::Clientbound>,
+    /// The entity events queued for that guest.
+    entity_events: Vec<i8>,
     /// The host's count of swings started, kept while the guest acts.
     swings: u32,
     /// How many projectiles there were: those added since are the guest's.
@@ -265,8 +273,10 @@ impl Game<'_> {
         }
         let mut play = host.play.remove(&conn).unwrap_or_default();
         if fresh {
-            // A new body (joined, respawned, changed level): nothing on it yet.
+            // A new body (joined, respawned, changed level): nothing on it yet,
+            // its effects' modifiers and armor protection included.
             play.equipped = None;
+            play.potions = Default::default();
             play.sculk = Default::default();
         }
         let g = &mut host.hub.guests[i];
@@ -382,6 +392,7 @@ impl Game<'_> {
         std::mem::swap(&mut self.hook, &mut play.hook);
         let adv_loaded = std::mem::replace(&mut self.adv.loaded, true);
         let last_inventory = std::mem::replace(&mut self.adv.last_inventory, play.last_inventory);
+        let levitation = std::mem::replace(&mut self.adv.levitation, play.levitation);
         let death_cause = std::mem::replace(&mut self.ui.death_cause, play.death_cause.take());
         let acting = (
             self.lan_acting.replace(conn),
@@ -389,6 +400,7 @@ impl Game<'_> {
             self.lan_acting_uuid.replace(g.uuid),
         );
         let packets = std::mem::take(&mut self.guest_packets);
+        let entity_events = std::mem::take(&mut self.guest_entity_events);
         let swings = self.swings_started;
         let projectiles = self.creatures.projectiles.len();
         let modifiers = std::mem::replace(
@@ -402,6 +414,12 @@ impl Game<'_> {
             self.apply_equipment();
             play.equipped = Some(equipped);
         }
+        // The player's effects are on the new body before anything it does
+        // (the movement that brought it, a landing): vanilla keeps the same
+        // entity through a level change, with its attributes and effects.
+        if fresh {
+            self.apply_effect_status();
+        }
         self.update_totem_ready();
         Some(GuestSwap {
             conn,
@@ -446,9 +464,11 @@ impl Game<'_> {
             host_ender,
             adv_loaded,
             last_inventory,
+            levitation,
             death_cause,
             acting,
             packets,
+            entity_events,
             swings,
             projectiles,
             modifiers,
@@ -504,10 +524,12 @@ impl Game<'_> {
             host_ender,
             adv_loaded,
             last_inventory,
+            levitation,
             death_cause,
             combat,
             acting,
             packets,
+            entity_events,
             swings,
             projectiles,
             modifiers,
@@ -529,6 +551,17 @@ impl Game<'_> {
         for packet in std::mem::replace(&mut self.guest_packets, packets) {
             host.hub.send_to(conn, &packet);
         }
+        // ServerPlayer.connection.send: the guest's own entity events.
+        let entity_id = host.hub.guests[i].entity_id;
+        for event in std::mem::replace(&mut self.guest_entity_events, entity_events) {
+            host.hub.send_to(
+                conn,
+                &C::EntityEvent(play::EntityEvent {
+                    id: entity_id,
+                    event,
+                }),
+            );
+        }
         // ServerItemCooldowns.onCooldownStarted: the guest's own cooldown.
         for (group, duration) in std::mem::take(&mut self.guest_cooldowns) {
             host.hub.send_to(
@@ -614,6 +647,7 @@ impl Game<'_> {
         std::mem::swap(&mut self.hook, &mut play.hook);
         self.adv.loaded = adv_loaded;
         play.last_inventory = std::mem::replace(&mut self.adv.last_inventory, last_inventory);
+        play.levitation = std::mem::replace(&mut self.adv.levitation, levitation);
         let stat_events = std::mem::take(&mut play.stats.events);
         let name = g.name.clone();
         self.potions.swap_player(&mut g.effects, &mut play.potions);
@@ -657,6 +691,13 @@ impl Game<'_> {
                 g.sprinting = false;
             }
             m.sprinting = false;
+            // ServerPlayer.indicateDamage: the hit's direction to the player.
+            if let Some(yaw) = m.health.indicated_dir.take() {
+                g.send(&C::HurtAnimation(play::HurtAnimation {
+                    id: g.entity_id,
+                    yaw,
+                }));
+            }
             let teleported = std::mem::take(&mut m.teleported);
             let moved: f64 = (0..3).map(|k| (at[k] - g.position[k]).powi(2)).sum();
             g.motion = Some(Box::new(m));
@@ -858,13 +899,17 @@ impl Game<'_> {
     }
 
     /// The guest's open container is closing (`AbstractContainerMenu.removed`):
-    /// it no longer counts among the openers of the lid.
+    /// it no longer counts among the openers of the lid, and the lid's close
+    /// sound is played for everyone around (`ChestBlockEntity.onClose`, a
+    /// `playSound` with no player), the guest included, once the last opener
+    /// has left.
     pub(super) fn guest_container_closed(&mut self, host: &mut LanHost, conn: u32) {
         if let Some(g) = host.hub.guest(conn)
             && let Some(pos) = g.menu.as_ref().and_then(|m| m.pos)
             && !g.spectator()
+            && self.container_openers_changed(pos, false)
         {
-            self.container_openers_changed(pos, false);
+            self.container_edge_sound(pos, false);
         }
     }
 
@@ -958,6 +1003,20 @@ impl Game<'_> {
                     // The pause between two blocks is the client's (MultiPlayerGameMode's
                     // destroyDelay); the server digs from the START it receives.
                     play.destroy_delay = 0;
+                    // ServerPlayerGameMode.handleBlockBreakAction: a survival START
+                    // attacks the block at once, so a tap released in the same tick
+                    // still plays a note. The dig is marked begun for tick_mining.
+                    let pos = a.pos;
+                    self.as_guest(host, conn, |g| {
+                        if g.may_build() && !g.creative {
+                            let _ = g.attack_block(pos);
+                            g.mining = Some(Mining {
+                                pos,
+                                progress: 0.0,
+                                ticks: 0,
+                            });
+                        }
+                    });
                 }
                 1 => {}
                 3 => {
@@ -1200,6 +1259,7 @@ impl Game<'_> {
             }
             S::RenameItem(p) => self.lan_station_rename(host, conn, &p.name),
             S::SignUpdate(p) => self.lan_sign_update(host, conn, p),
+            S::SetCommandBlock(p) => self.lan_set_command_block(host, conn, p),
             S::EditBook(p) => self.lan_edit_book(host, conn, p),
             S::ContainerSlotStateChanged(p) => {
                 self.lan_crafter_slot_state(host, conn, p.container, p.slot, p.enabled);
@@ -1216,6 +1276,12 @@ impl Game<'_> {
             {
                 self.guest_carried_back(host, gi);
             }
+            S::SelectBundleItem(p) => {
+                if !spectator && let Ok(slot) = usize::try_from(p.slot) {
+                    host.hub
+                        .select_bundle_item(conn, slot, p.index, &mut self.world);
+                }
+            }
             S::ContainerClick(p) => {
                 let rules = ItemRules(self.res.items());
                 let slots = host.hub.guests[gi]
@@ -1518,9 +1584,13 @@ impl Game<'_> {
         if let Some(victim) = Self::pvp_victim(host, conn, id) {
             if let Some(Some(strike)) = self.as_guest(host, conn, |g| g.pvp_strike())
                 && self.pvp_land(host, victim, &strike)
-                && strike.stops_sprint()
             {
-                self.as_guest(host, conn, |g| g.stop_sprint_after_extra_knockback());
+                self.as_guest(host, conn, |g| {
+                    g.pvp_exhaustion();
+                    if strike.stops_sprint() {
+                        g.stop_sprint_after_extra_knockback();
+                    }
+                });
             }
             return;
         }
@@ -1825,10 +1895,6 @@ impl Game<'_> {
         };
         xp.respawn(self.ui.rules.bool("keep_inventory") || g.game_mode == SPECTATOR);
         (g.xp_level, g.xp_progress, g.xp_total) = (xp.level, xp.progress, xp.total);
-        // A new body: nothing given to the old one carries over.
-        if let Some(play) = host.play.get_mut(&conn) {
-            play.potions = Default::default();
-        }
         let clock_rate = self.network_clock_rate();
         let ctx = TickCtx {
             world: &mut self.world,
@@ -1910,21 +1976,8 @@ impl Game<'_> {
                 continue;
             }
             let play = host.play.entry(conn).or_default();
-            // Player.tick's ItemCooldowns.tick, once a tick for each player
-            // (the shield an axe disabled, a thrown pearl).
-            play.shield_cooldown = play.shield_cooldown.saturating_sub(1);
+            // ServerGamePacketListenerImpl.tick's dropSpamThrottler.
             play.creative_drops = play.creative_drops.saturating_sub(1);
-            // ServerItemCooldowns.onCooldownEnded: a finished entry is told to
-            // the guest (a duration of 0 removes it).
-            for group in play.cooldowns.tick() {
-                host.hub.send_to(
-                    conn,
-                    &C::Cooldown(play::Cooldown {
-                        group: group.to_string(),
-                        duration: 0,
-                    }),
-                );
-            }
             let digging = play.digging;
             let using = play.using.is_some();
             let delayed = play.destroy_delay > 0 || play.use_delay > 0 || play.attack_ticks < 100;
@@ -1961,6 +2014,24 @@ impl Game<'_> {
                     play.digging = None;
                 }
             }
+            // Player.tick's ItemCooldowns.tick, once a tick for each player
+            // (the shield an axe disabled, a thrown pearl), after
+            // LivingEntity.tick's use: an entry a finished use starts has 20
+            // ticks left when the next tick's packets are handled, as the
+            // guest's own client counts.
+            let play = host.play.entry(conn).or_default();
+            play.shield_cooldown = play.shield_cooldown.saturating_sub(1);
+            // ServerItemCooldowns.onCooldownEnded: a finished entry is told to
+            // the guest (a duration of 0 removes it).
+            for group in play.cooldowns.tick() {
+                host.hub.send_to(
+                    conn,
+                    &C::Cooldown(play::Cooldown {
+                        group: group.to_string(),
+                        duration: 0,
+                    }),
+                );
+            }
             // Player.tick: a different main-hand item resets the attack
             // strength, and detectEquipmentUpdates gives the guest its modifiers.
             let g = &host.hub.guests[gi];
@@ -2182,7 +2253,8 @@ impl Game<'_> {
         }
         let in_wall = !g.sleeping && self.in_wall(g.position, g.eye_height());
         let at = g.position;
-        let sneaking = g.sneaking;
+        let (sneaking, sleeping) = (g.sneaking, g.sleeping);
+        let mut soul = None;
         let events = self.as_guest(host, conn, |game| {
             let (rules, motion) = (game.world.health_rules, game.motion);
             let health = &motion.health;
@@ -2250,8 +2322,10 @@ impl Game<'_> {
             // Entity.applyEffectsFromBlocks along those moves: magma, cactus,
             // lit campfires and grown sweet berry bushes hurt (#1305).
             w.player.shift_key_down = sneaking;
+            let _ = w.player.set_sleeping(sleeping);
             w.player.freeze_immune = freeze_immune;
             let _ = w.server_block_damage(start);
+            let _ = w.update_soul_speed_block();
             let _ = w.tick_environment_damage();
             let _ = w.apply_fire_contact();
             let _ = w.server_hazards_tick(in_wall);
@@ -2265,6 +2339,8 @@ impl Game<'_> {
                     game.cauldron_extinguish(*pos);
                 }
             }
+            // Entity.baseTick: rain puts out a burning player.
+            game.rain_extinguish_player();
             // WitherRoseBlock.entityInside along those moves.
             for event in &events {
                 if matches!(event, MotionEvent::InsideWitherRose) {
@@ -2279,6 +2355,9 @@ impl Game<'_> {
             // LivingEntity.baseTick: outside the world border, then tickEffects.
             game.border_damage();
             game.tick_mob_effects();
+            // Soul Speed's effects (LivingEntity.baseTick's location_changed
+            // and tick effects); its particle goes to the players around.
+            soul = game.tick_soul_speed();
             let Some(player) = game.player.as_mut() else {
                 return (Vec::new(), None);
             };
@@ -2300,17 +2379,65 @@ impl Game<'_> {
             // ServerEntity.sendChanges sends it as it is after this travel.
             let marked = std::mem::take(&mut player.health.sync_velocity);
             let velocity = marked.then_some(player.velocity);
+            // Player.causeFallDamage: a fall of 2 blocks or more counts.
+            for event in &events {
+                if let MotionEvent::Fall(horizon_client::landing::FallEvent::Statistic(cm)) = event
+                {
+                    game.stats.custom("fall_one_cm", *cm);
+                }
+            }
             game.record_combat(&events);
+            game.wear_armor(&events);
             (events, velocity)
         });
         let Some((events, marked)) = events else {
             return;
         };
+        if let Some((at, velocity)) = soul {
+            super::lan_particles::send_soul_particle(host, at, velocity);
+        }
         self.as_guest(host, conn, |game| game.tick_player_sculk_events());
         for event in events {
             match event {
                 MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, at),
+                // LivingEntity.checkFallDamage: the crumbs reach every player.
+                MotionEvent::Fall(horizon_client::landing::FallEvent::Particles {
+                    state,
+                    position,
+                    count,
+                    speed,
+                }) => self.landing_dust(Some(host), state, position, count, speed),
                 MotionEvent::Fall(event) => self.landing_block_updates(&event),
+                // LivingEntity.baseTick's entity event 67, to every client
+                // around, the guest's own included; this window draws it too.
+                MotionEvent::Drown => {
+                    if let Some(g) = host.hub.guest(conn) {
+                        host.hub
+                            .entity_event(g.entity_id, super::combat::DROWN_EVENT, at);
+                    }
+                    self.drown_particles(at, [0.0; 3]);
+                }
+                // HoneyBlock.maybeDoSlideEffects: the sound reaches the
+                // others (Player.playSound excludes the player, whose client
+                // plays it), the entity event 53 everyone around.
+                MotionEvent::HoneySlide {
+                    sound, particles, ..
+                } => {
+                    let Some((id, at)) = host.hub.guest(conn).map(|g| (g.entity_id, g.position))
+                    else {
+                        continue;
+                    };
+                    if sound {
+                        let name = "minecraft:block.honey_block.slide";
+                        let source = horizon_client::settings::sound_source(name) as i32;
+                        self.audio.play_unshared(name, Some(at), 1.0, 1.0);
+                        host.hub.sound(name, at, 1.0, 1.0, source, Some(conn));
+                    }
+                    if particles {
+                        self.honey_slide_particles(at);
+                        host.hub.entity_event(id, 53, at);
+                    }
+                }
                 _ => {}
             }
         }
@@ -2394,9 +2521,13 @@ impl Game<'_> {
             }
             if (next / 10) % 2 == 0
                 && !creative
-                && let Some(elytra) = game.armor[1].as_mut()
+                && let Some(stack) = game.armor[1].clone()
             {
-                elytra.damage += 1;
+                // `ItemStack.hurtAndBreak`: Unbreaking can save the wear.
+                let loss = game.durability_loss(&stack, 1);
+                if let Some(elytra) = game.armor[1].as_mut() {
+                    elytra.damage += loss;
+                }
             }
             let ctx = game.player_context(None);
             game.post_game_event("minecraft:elytra_glide", at, ctx);
@@ -2621,8 +2752,7 @@ impl Game<'_> {
     /// with Mending and gives the rest as points. Everyone near hears it.
     fn guest_orbs(&mut self, host: &mut LanHost, gi: usize) {
         let g = &host.hub.guests[gi];
-        // Player's standing and crouching boxes: 1.8 and 1.5 high.
-        let height = if g.sneaking { 1.5 } else { 1.8 };
+        let height = f64::from(g.dimensions().height);
         let (conn, id, at) = (g.conn, g.entity_id, g.position);
         let unable = g.spectator() || g.dead || g.health <= 0.0;
         let play = host.play.entry(conn).or_default();
@@ -2659,7 +2789,13 @@ impl Game<'_> {
             .random
             .next_int_bound(touching.len() as i32)
             .unwrap_or(0) as usize;
-        let orb = self.orbs.remove(touching[pick]);
+        // A merged orb gives its value once per count and goes at zero.
+        let orb = self.orbs[touching[pick]].clone();
+        if orb.count <= 1 {
+            self.orbs.remove(touching[pick]);
+        } else {
+            self.orbs[touching[pick]].count -= 1;
+        }
         play.xp_delay = 2;
         host.hub.take_item(orb.id as i32, id, 1, at);
         // ClientPacketListener.handleTakeItemEntity's sound, at the orb.
diff --git a/crates/horizon-client/src/game/lan_crafting.rs b/crates/horizon-client/src/game/lan_crafting.rs
index db6235c4d..461eaf5e1 100644
--- a/crates/horizon-client/src/game/lan_crafting.rs
+++ b/crates/horizon-client/src/game/lan_crafting.rs
@@ -127,9 +127,18 @@ impl Game<'_> {
         }
         let dropped = std::mem::take(&mut menu.dropped);
         let equipped = std::mem::take(&mut menu.equipped);
+        let brewed = std::mem::take(&mut menu.brewed);
         menu.drops.clear();
         menu.crafted.clear();
         store_player(menu, &mut host.hub.guests[gi]);
+        if !brewed.is_empty() {
+            let conn = host.hub.guests[gi].conn;
+            self.as_guest(host, conn, |g| {
+                for stack in &brewed {
+                    g.trigger_brewed_potion(stack);
+                }
+            });
+        }
         if !equipped.is_empty() {
             let conn = host.hub.guests[gi].conn;
             self.as_guest(host, conn, |g| {
@@ -576,16 +585,18 @@ impl Game<'_> {
     /// A guest left: what their crafting grids and workstation held goes back into their
     /// inventory before it is saved (dropped where they stood if full).
     pub(super) fn lan_crafting_left(&mut self, host: &mut LanHost, g: &mut Guest) {
-        let play = host.play.remove(&g.conn);
+        // The guest's play state stays: their statistics are awarded and saved
+        // after this (`HostEvent::Left`), which removes it.
+        let play = host.play.get_mut(&g.conn);
         let mut grid: Vec<ItemStack> = g.craft_grid.iter_mut().filter_map(Option::take).collect();
         g.craft_result = None;
         if let Some(play) = play {
-            if let Some((_, _, menu, _)) = play.crafting.table {
+            if let Some((_, _, menu, _)) = play.crafting.table.take() {
                 grid.extend((1..10).filter_map(|s| menu.slot(s).cloned()));
             }
             // A workstation's inputs too.
-            if let Some(station) = &play.station {
-                grid.extend(super::lan_stations::station_inputs(station));
+            if let Some(station) = play.station.take() {
+                grid.extend(super::lan_stations::station_inputs(&station));
             }
         }
         if grid.is_empty() {
diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs
index 3c5b11988..a1d330928 100644
--- a/crates/horizon-client/src/game/lan_entities.rs
+++ b/crates/horizon-client/src/game/lan_entities.rs
@@ -225,6 +225,16 @@ impl Game<'_> {
             }
             out.push(e);
         }
+        for (p, &id) in &self.knot_ids {
+            // LeashFenceKnotEntity.getAddEntityPacket: the fence's block.
+            out.push(state(
+                id,
+                "minecraft:leash_knot",
+                p.map(f64::from),
+                0.0,
+                false,
+            ));
+        }
         for p in &self.paintings {
             let mut e = state(p.id, "minecraft:painting", p.pos.map(f64::from), 0.0, false);
             // Direction.get2DDataValue (south 0, west 1, north 2, east 3) to its
@@ -270,6 +280,24 @@ impl Game<'_> {
     /// Gives the entities Horizon keeps without an id one (`Entity.id`, from
     /// the same counter as the rest) before they are first tracked.
     pub(super) fn lan_assign_ids(&mut self) {
+        // LeashFenceKnotEntity: one per fence post with a lead on it
+        // (`notifyLeasheeRemoved` discards it once the last lead is gone).
+        let knots: Vec<[i32; 3]> = self
+            .mobs
+            .iter()
+            .filter(|m| !m.removed)
+            .filter_map(|m| match m.extra.leash {
+                Some(horizon_client::mobs::leash::Holder::Knot(p)) => Some(p),
+                _ => None,
+            })
+            .collect();
+        self.knot_ids.retain(|p, _| knots.contains(p));
+        for p in knots {
+            self.knot_ids.entry(p).or_insert_with(|| {
+                self.next_entity += 1;
+                self.next_entity
+            });
+        }
         let next = &mut self.next_entity;
         let mut give = |id: &mut u32| {
             if *id == 0 {
@@ -304,6 +332,9 @@ impl Game<'_> {
             None => 0,
         };
         let at = |p: horizon_core::geometry::Vec3| [p.x, p.y, p.z];
+        for f in &self.fangs.list {
+            out.push(state(f.id, "minecraft:evoker_fangs", f.pos, f.yaw, false));
+        }
         // LightningBolt: each client draws and flashes its own.
         for b in self.bolts.iter().filter(|b| b.id != 0) {
             out.push(state(b.id, "minecraft:lightning_bolt", b.at, 0.0, false));
@@ -339,6 +370,7 @@ impl Game<'_> {
             let mut e = state(p.id, kind, at(p.position), p.yaw, false);
             e.pitch = p.pitch;
             e.velocity = at(p.velocity);
+            e.needs_sync = p.needs_sync;
             // Projectile.getAddEntityPacket: the owner's id.
             e.data = match p.guest.and_then(|conn| hub.guest(conn)) {
                 Some(g) => g.entity_id,
@@ -354,6 +386,20 @@ impl Game<'_> {
                         a.is_some_and(|a| a.in_ground) || p.stuck,
                     ));
                 }
+                // ThrownTrident.ID_LOYALTY (none for a mob's) and ID_FOIL, on
+                // AbstractArrow's flags.
+                K::Trident => {
+                    let a = p.arrow.as_deref();
+                    e.meta.extend(arrow_meta(
+                        false,
+                        a.is_some_and(|a| a.no_physics),
+                        0,
+                        a.is_some_and(|a| a.in_ground) || p.stuck,
+                    ));
+                    if a.is_some_and(|a| a.pickup_item.has_any_enchantments()) {
+                        e.meta.push((12, serializer::BOOLEAN, Value::Bool(true)));
+                    }
+                }
                 // WitherSkull.DATA_DANGEROUS.
                 K::WitherSkull { dangerous: true } => {
                     e.meta.push((8, serializer::BOOLEAN, Value::Bool(true)));
@@ -452,7 +498,7 @@ impl Game<'_> {
             }
             out.push(e);
         }
-        // The dragon's breath clouds (AreaEffectCloud's DATA_RADIUS,
+        // The dragon's breath and lingering potion clouds (AreaEffectCloud's DATA_RADIUS,
         // DATA_WAITING for its 20-tick wait, and DATA_PARTICLE): the
         // client draws them from these (`tick_remote_clouds`).
         let breath = self.network_particle(
@@ -470,10 +516,14 @@ impl Game<'_> {
         for b in self.breath_clouds.iter().filter(|b| b.id != 0) {
             let mut e = state(b.id, "minecraft:area_effect_cloud", b.at, 0.0, false);
             e.meta.push((8, serializer::FLOAT, Value::Float(b.radius)));
-            if b.age < 20 {
+            if b.waiting() {
                 e.meta.push((9, serializer::BOOLEAN, Value::Bool(true)));
             }
-            if let Some(p) = &breath {
+            let particle = match &b.potion {
+                Some(p) => self.network_particle(&p.particle(), None),
+                None => breath.clone(),
+            };
+            if let Some(p) = &particle {
                 e.meta
                     .push((10, serializer::PARTICLE, Value::Particle(p.clone())));
             }
diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs
index 4f53cec60..49eedbe55 100644
--- a/crates/horizon-client/src/game/lan_mobs.rs
+++ b/crates/horizon-client/src/game/lan_mobs.rs
@@ -5,7 +5,7 @@
 //! (hits, pushes, fire, its projectiles) runs with that guest swapped in.
 use super::{Game, lan::LanHost};
 use horizon_client::{
-    mobs::{Mob, MobEvent, PlayerView, Who},
+    mobs::{Mob, MobEvent, PlayerView, Species, Who},
     projectiles::{Hit, Projectile},
 };
 use horizon_core::geometry::{Aabb, Vec3};
@@ -28,6 +28,22 @@ pub(super) fn player_for(
 ) -> Option<u32> {
     let targeting = m.ai.target == Some(Who::Player)
         || m.ai.last_hurt_by == Some(Who::Player) && m.age as i32 - m.ai.last_hurt_by_time <= 100;
+    // A tame wolf or cat sees its owner (`TamableAnimal.getOwner`), while they
+    // are in play, whoever is nearer. Not while it targets or was just hurt by
+    // a player: then `Who::Player` is that attacker, whoever it is, and the
+    // owner goals ignore it until the wolf lets go.
+    if !targeting
+        && matches!(m.species(), Species::Wolf | Species::Cat)
+        && m.extra.tame
+        && let Some(owner) = m.extra.owner
+    {
+        if host.is_some_and(|v| v.alive && v.uuid == owner) {
+            return None;
+        }
+        if let Some((conn, _)) = guests.iter().find(|(_, v)| v.alive && v.uuid == owner) {
+            return Some(*conn);
+        }
+    }
     choose(m.position, targeting, host, guests, bound)
 }
 
@@ -175,9 +191,9 @@ impl Game<'_> {
             .iter()
             .filter(|g| host.hub.here(g) && g.loaded && !g.dead && !g.spectator())
             .map(|g| {
-                let [x, y, z] = g.position;
-                let height = if g.sneaking { 1.5 } else { 1.8 };
-                ([x - 0.3, y, z - 0.3], [x + 0.3, y + height, z + 0.3])
+                let b = g.bounds();
+                let (lo, hi) = (b.min_position(), b.max_position());
+                ([lo.x, lo.y, lo.z], [hi.x, hi.y, hi.z])
             })
             .collect()
     }
@@ -319,7 +335,7 @@ impl Game<'_> {
                     uuid: horizon_client::lan::playerdata::uuid_ints(g.uuid),
                     position: g.position,
                     eye: [x, y + g.eye_height(), z],
-                    height: if g.sneaking { 1.5 } else { 1.8 },
+                    height: g.dimensions().height,
                     creative: g.creative(),
                     spectator: g.spectator(),
                     alive: !g.dead,
@@ -336,14 +352,9 @@ impl Game<'_> {
     }
 }
 
-/// A guest's bounding box (0.6 wide, 1.8 tall, 1.5 crouching).
+/// A guest's bounding box, by its pose (`Avatar.POSES`).
 pub(super) fn guest_bounds(g: &horizon_client::lan::guest::Guest) -> Aabb {
-    let [x, y, z] = g.position;
-    let height = if g.sneaking { 1.5 } else { 1.8 };
-    Aabb::new(
-        Vec3::new(x - 0.3, y, z - 0.3),
-        Vec3::new(x + 0.3, y + height, z + 0.3),
-    )
+    g.bounds()
 }
 
 #[cfg(test)]
@@ -363,6 +374,7 @@ mod tests {
             off_hand: None,
             head: None,
             armor_cover: 0.0,
+            invisible: false,
             spectator: false,
             gold_armor: false,
             hurt_by: None,
@@ -370,9 +382,11 @@ mod tests {
             velocity: Vec3::ZERO,
             yaw: 0.0,
             hero: false,
+            effects: Vec::new(),
             uuid: [0; 4],
             allies: Default::default(),
             remote: false,
+            passenger: false,
         }
     }
 
diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs
index c41fdf1ad..aa5981e0b 100644
--- a/crates/horizon-client/src/game/lan_particles.rs
+++ b/crates/horizon-client/src/game/lan_particles.rs
@@ -1,7 +1,8 @@
 //! Particles a server sends its players and its clients draw:
 //! `ClientboundLevelParticlesPacket` (`ServerLevel.sendParticles`, which
 //! `/particle` uses) and `ClientboundExplodePacket` (`ServerLevel.explode`).
-use super::Game;
+use super::{Game, lan::LanHost};
+use horizon_client::lan::hub::Hub;
 use horizon_client::particles::{ParticleOptions, ParticleType};
 use horizon_core::{geometry::Vec3, random::RandomSource};
 use horizon_protocol::{
@@ -24,6 +25,35 @@ fn rgb(c: [f32; 4]) -> [f32; 3] {
     [c[0], c[1], c[2]]
 }
 
+/// `ServerLevel.sendParticles` of one soul particle moving by `velocity`
+/// (Soul Speed's `spawn_particles`): sent to the players within 32 blocks.
+pub(super) fn send_soul_particle(host: &super::lan::LanHost, at: [f64; 3], velocity: [f64; 3]) {
+    let Some(id) = host
+        .hub
+        .registry_id("minecraft:particle_type", "minecraft:soul")
+    else {
+        return;
+    };
+    let packet = C::LevelParticles(play::LevelParticles {
+        particle: Particle { id, data: None },
+        override_limiter: false,
+        always_show: false,
+        pos: at,
+        dist: velocity.map(|v| v as f32),
+        max_speed: [1.0; 3],
+        count: 0,
+        randomization: 0,
+    });
+    for g in host.hub.guests.iter().filter(|g| host.hub.here(g)) {
+        let distance: f64 = (0..3)
+            .map(|k| (g.position[k].floor() + 0.5 - at[k]).powi(2))
+            .sum();
+        if distance < 32.0 * 32.0 {
+            g.send(&packet);
+        }
+    }
+}
+
 impl Game<'_> {
     /// `SonicBoom.tick` uses `ServerLevel.sendParticles` for each ray point.
     /// Keep the local event's rendering; connected players receive one at rest.
@@ -52,6 +82,66 @@ impl Game<'_> {
         }
     }
 
+    /// `LivingEntity.checkFallDamage`'s `ServerLevel.sendParticles` of the
+    /// landing block's crumbs: drawn in this window, when it has one, and
+    /// sent to each player within 32 blocks. `host` is the hub of a guest's
+    /// turn, which is out of `self.lan` meanwhile.
+    pub(super) fn landing_dust(
+        &mut self,
+        host: Option<&LanHost>,
+        state: BlockStateId,
+        at: Vec3,
+        count: i32,
+        speed: f64,
+    ) {
+        let at = [at.x, at.y, at.z];
+        if self.serving.is_none() && self.options.dedicated.is_none() {
+            let block = [
+                at[0].floor() as i32,
+                (at[1] - 0.2).floor() as i32,
+                at[2].floor() as i32,
+            ];
+            if let Some((sprite, tint)) = self.particle_sprite(state, block) {
+                self.particles.send_particles(
+                    &ParticleOptions::block(ParticleType::Block, sprite, tint),
+                    at,
+                    [0.0; 3],
+                    speed,
+                    count as u32,
+                );
+            }
+        }
+        let Some(hub) = host.or(self.lan.as_ref()).map(|h| &h.hub) else {
+            return;
+        };
+        let Some(particle) = Self::hub_particle(
+            hub,
+            &ParticleOptions::simple(ParticleType::Block),
+            Some(state),
+        ) else {
+            return;
+        };
+        let packet = C::LevelParticles(play::LevelParticles {
+            particle,
+            override_limiter: false,
+            always_show: false,
+            pos: at,
+            dist: [0.0; 3],
+            max_speed: [speed as f32; 3],
+            count,
+            randomization: 0,
+        });
+        for g in hub.guests.iter().filter(|g| hub.here(g)) {
+            // ServerLevel compares the player's block centre, strictly within 32.
+            let distance: f64 = (0..3)
+                .map(|k| (g.position[k].floor() + 0.5 - at[k]).powi(2))
+                .sum();
+            if distance < 32.0 * 32.0 {
+                g.send(&packet);
+            }
+        }
+    }
+
     /// `ParticleTypes.STREAM_CODEC`'s value for `options`: the type's
     /// network id and the data it carries (`state` for the block particles).
     /// None while not serving, or for a particle whose data isn't sent from
@@ -60,13 +150,19 @@ impl Game<'_> {
         &self,
         options: &ParticleOptions,
         state: Option<BlockStateId>,
+    ) -> Option<Particle> {
+        Self::hub_particle(&self.lan.as_ref()?.hub, options, state)
+    }
+
+    /// `network_particle` for a hub that is out of `self.lan` meanwhile (a
+    /// guest's turn).
+    fn hub_particle(
+        hub: &Hub,
+        options: &ParticleOptions,
+        state: Option<BlockStateId>,
     ) -> Option<Particle> {
         let name = format!("minecraft:{}", options.ty.name());
-        let id = self
-            .lan
-            .as_ref()?
-            .hub
-            .registry_id("minecraft:particle_type", &name)?;
+        let id = hub.registry_id("minecraft:particle_type", &name)?;
         use ParticleType as T;
         let c = options.color;
         let data = match options.ty {
@@ -151,14 +247,10 @@ impl Game<'_> {
             return;
         };
         let (d, s) = (p.dist.map(f64::from), p.max_speed.map(f64::from));
-        // ClientLevel.addParticle: the camera's 32 blocks unless the packet
-        // (`force`) or the type overrides the limiter.
+        // ClientLevel.addParticle: the camera's 32 blocks and the Particles
+        // option, unless the packet or the type overrides the limiter.
         let add = |particles: &mut horizon_client::particles::ParticleEngine, at, v| {
-            if p.override_limiter {
-                particles.create(&options, at, v);
-            } else {
-                particles.add(&options, at, v);
-            }
+            particles.add_with(&options, at, v, p.override_limiter, p.always_show);
         };
         if p.count == 0 {
             add(
@@ -222,11 +314,87 @@ impl Game<'_> {
         }
     }
 
+    /// `ServerLevel.sendParticles` for the players a server serves: one
+    /// `ClientboundLevelParticlesPacket` to each player in the level whose
+    /// block is within 32 blocks of `at`. The window's own player is not
+    /// sent it (the caller draws it in this window). While the host holds
+    /// the players (a guest's turn through `as_guest`, a host's hit on a
+    /// guest) the packet waits for the turn to end so that it reaches every
+    /// player, the guest too.
+    pub(super) fn lan_send_particles(
+        &mut self,
+        options: &ParticleOptions,
+        at: [f64; 3],
+        spread: [f64; 3],
+        speed: f64,
+        count: u32,
+    ) {
+        if self.lan.is_none() {
+            // The server is running (its sounds are captured for the guests).
+            if self.audio.capture.is_some() {
+                self.creatures
+                    .lan_particles
+                    .push((options.clone(), at, spread, speed, count));
+            }
+            return;
+        }
+        let Some(particle) = self.network_particle(options, None) else {
+            return;
+        };
+        let Some(host) = self.lan.as_ref() else {
+            return;
+        };
+        let body = C::LevelParticles(play::LevelParticles {
+            particle,
+            override_limiter: false,
+            always_show: false,
+            pos: at,
+            dist: spread.map(|d| d as f32),
+            max_speed: [speed as f32; 3],
+            count: count as i32,
+            randomization: 0,
+        })
+        .encode();
+        for g in host.hub.guests.iter().filter(|g| host.hub.here(g)) {
+            // BlockPos.closerToCenterThan(at, 32): from the centre of the
+            // player's block.
+            let d: f64 = (0..3)
+                .map(|k| (g.position[k].floor() + 0.5 - at[k]).powi(2))
+                .sum();
+            if d < 32.0 * 32.0 {
+                g.sender.send(body.clone());
+            }
+        }
+    }
+
+    /// The particles guests' turns put off.
+    pub(super) fn flush_lan_particles(&mut self) {
+        for (options, at, spread, speed, count) in std::mem::take(&mut self.creatures.lan_particles)
+        {
+            self.lan_send_particles(&options, at, spread, speed, count);
+        }
+    }
+
     /// `ServerLevel.explode`'s packet to each player within 64 blocks. The
     /// sound and the push reach them on their own (the level's sounds, the
     /// motion a hurt player is sent), so the packet carries neither.
-    pub(super) fn lan_explode(&self, center: [f64; 3], radius: f32, block_count: usize) {
-        let emitter = if radius < 2.0 {
+    pub(super) fn lan_explode(
+        &mut self,
+        center: [f64; 3],
+        small: bool,
+        radius: f32,
+        block_count: usize,
+    ) {
+        // In a guest's turn (their hit on an end crystal or a minecart) the
+        // host holds the players (`as_guest`): the packet waits for the turn
+        // to end so that it reaches every player, the guest too.
+        if self.lan_acting.is_some() && self.lan.is_none() {
+            self.creatures
+                .lan_explosions
+                .push((center, small, radius, block_count));
+            return;
+        }
+        let emitter = if small {
             "minecraft:explosion"
         } else {
             "minecraft:explosion_emitter"
@@ -239,6 +407,15 @@ impl Game<'_> {
         }
     }
 
+    /// The explosions guests' turns put off.
+    pub(super) fn flush_lan_explosions(&mut self) {
+        for (center, small, radius, block_count) in
+            std::mem::take(&mut self.creatures.lan_explosions)
+        {
+            self.lan_explode(center, small, radius, block_count);
+        }
+    }
+
     /// A wind charge's burst (`AbstractWindCharge.explode`): gust emitters,
     /// no block particles, and for each player it pushed the push
     /// (`ServerExplosion.hitPlayers`), which only that client applies, as
diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs
index 8e756b7be..937fa28f4 100644
--- a/crates/horizon-client/src/game/lan_pvp.rs
+++ b/crates/horizon-client/src/game/lan_pvp.rs
@@ -37,6 +37,8 @@ pub(super) struct Strike {
     amount: f32,
     scale: f32,
     crit: bool,
+    /// `Player.attack`'s `magicBoost > 0`: the enchantments added damage.
+    magic: bool,
     from: [f64; 3],
     sweep: Option<[f64; 3]>,
     /// `causeExtraKnockback`: its strength and direction (the attacker's
@@ -84,9 +86,11 @@ impl Game<'_> {
         };
         if let Some(strike) = self.pvp_strike()
             && self.pvp_land(&mut host, Victim::Guest(conn), &strike)
-            && strike.stops_sprint()
         {
-            self.stop_sprint_after_extra_knockback();
+            self.pvp_exhaustion();
+            if strike.stops_sprint() {
+                self.stop_sprint_after_extra_knockback();
+            }
         }
         self.lan = Some(host);
         true
@@ -104,27 +108,33 @@ impl Game<'_> {
             .map(|g| Victim::Guest(g.conn))
     }
 
-    /// The attacker's side of `Player.attack` (the host, or a guest swapped
-    /// in): the damage, the charge reset, the exhaustion and the swing.
-    pub(super) fn pvp_strike(&mut self) -> Option<Strike> {
-        let p = self.player.as_ref()?;
-        let from = [p.position.x, p.position.y, p.position.z];
-        let (amount, scale, crit) = self.melee_damage("minecraft:player");
-        let sweep = self.sweep_attack_position(scale, crit);
-        let (strength, knockback_attack) = self.extra_knockback("minecraft:player", scale);
-        let (xd, zd) = self.extra_knockback_direction();
-        self.attack_ticks = 0;
+    /// `Player.attack`'s `causeFoodExhaustion(0.1F)`, charged to the attacker
+    /// (the host, or a guest swapped in) only once the hit hurt the victim.
+    pub(super) fn pvp_exhaustion(&mut self) {
         if let Some(p) = self.player.as_mut()
             && !self.creative
         {
             p.cause_food_exhaustion(0.1);
         }
+    }
+
+    /// The attacker's side of `Player.attack` (the host, or a guest swapped
+    /// in): the damage, the charge reset and the swing.
+    pub(super) fn pvp_strike(&mut self) -> Option<Strike> {
+        let p = self.player.as_ref()?;
+        let from = [p.position.x, p.position.y, p.position.z];
+        let (amount, scale, crit, magic) = self.melee_damage("minecraft:player");
+        let sweep = self.sweep_attack_position(scale, crit);
+        let (strength, knockback_attack) = self.extra_knockback("minecraft:player", scale);
+        let (xd, zd) = self.extra_knockback_direction();
+        self.attack_ticks = 0;
         self.swing_arm();
         Some(Strike {
             attacker: self.lan_acting,
             amount,
             scale,
             crit,
+            magic,
             from,
             sweep,
             knockback: (strength, xd, zd),
@@ -257,7 +267,31 @@ impl Game<'_> {
         } else {
             Default::default()
         };
-        if hurt && s.crit {
+        // ServerPlayer.awardKillScore: the blow that kills a player.
+        if hurt {
+            let died = match victim {
+                // A totem that fired is applied on the next tick_totem, so the
+                // victim is still at zero health but is not dying.
+                Victim::Host => self
+                    .player
+                    .as_ref()
+                    .is_some_and(|p| p.health.dead_or_dying() && !p.health.totem_used),
+                Victim::Guest(conn) => host
+                    .hub
+                    .guest(conn)
+                    .and_then(|g| g.motion.as_deref())
+                    .is_some_and(|p| p.health.dead_or_dying() && !p.health.totem_used),
+            };
+            if died {
+                match s.attacker {
+                    Some(conn) => {
+                        self.as_guest(host, conn, |g| g.stats.custom("player_kills", 1));
+                    }
+                    None => self.stats.custom("player_kills", 1),
+                }
+            }
+        }
+        if hurt && (s.crit || s.magic) {
             let target = match victim {
                 Victim::Host => self.player.as_ref().map(|p| (host.host_entity, p)),
                 Victim::Guest(conn) => host
@@ -267,13 +301,17 @@ impl Game<'_> {
             };
             if let Some((id, p)) = target {
                 let d = p.dimensions;
-                self.critical_hit(
-                    s.attacker,
-                    id,
+                let (feet, width, height) = (
                     [p.position.x, p.position.y, p.position.z],
                     f64::from(d.width),
                     f64::from(d.height),
                 );
+                if s.crit {
+                    self.critical_hit(s.attacker, id, feet, width, height, false);
+                }
+                if s.magic {
+                    self.critical_hit(s.attacker, id, feet, width, height, true);
+                }
             }
         }
         // `Enchantment.doPostAttack`: thorns hurt the attacking player.
diff --git a/crates/horizon-client/src/game/lan_screen.rs b/crates/horizon-client/src/game/lan_screen.rs
index 260cc76c3..055d1ea1f 100644
--- a/crates/horizon-client/src/game/lan_screen.rs
+++ b/crates/horizon-client/src/game/lan_screen.rs
@@ -5,14 +5,10 @@
 //! forcing the game mode. Its difficulty lock asks first (PopupScreen), and
 //! Restrictions opens RestrictionsScreen.
 //! Parity reference: https://mcsrc.dev/2/26.3/net/minecraft/client/gui/screens/WorldOptionsScreen
-use super::{
-    Game, Screen,
-    game_rules_screen::{Exit, RulesScreen},
-    integrated::ServerOptions,
-    lan::LanSettings,
-};
+use super::{Game, Screen, integrated::ServerOptions, lan::LanSettings};
 use horizon_client::{
     font::Font,
+    game_rules_screen::{Exit, RulesScreen},
     hud::{HudBatch, rgba},
     text::{Text, named_color},
     ui::{self, EditBox},
diff --git a/crates/horizon-client/src/game/lan_trading.rs b/crates/horizon-client/src/game/lan_trading.rs
index 7beeeba2f..0177a24b1 100644
--- a/crates/horizon-client/src/game/lan_trading.rs
+++ b/crates/horizon-client/src/game/lan_trading.rs
@@ -277,7 +277,12 @@ impl Game<'_> {
             g.carried = menu.carried.take();
         }
         self.register_exploration_maps(made);
-        gm.merchant.session = self.merchant_apply(session, gm.merchant.mob);
+        let (session, traded) = self.merchant_apply(session, gm.merchant.mob);
+        gm.merchant.session = session;
+        if !traded.is_empty() {
+            // The guest's own statistic and advancements.
+            self.as_guest(host, conn, |g| g.merchant_traded(gm.merchant.mob, &traded));
+        }
         self.drop_guest_items(host, gi, dropped);
         self.lan_send_offers(host, conn, &mut gm, false);
         self.lan_send_merchant_content(host, conn, &mut gm);
diff --git a/crates/horizon-client/src/game/leads.rs b/crates/horizon-client/src/game/leads.rs
index 8867157ee..877609d57 100644
--- a/crates/horizon-client/src/game/leads.rs
+++ b/crates/horizon-client/src/game/leads.rs
@@ -104,6 +104,9 @@ impl Game<'_> {
             };
             let m = &mut self.mobs[i];
             if let Some(h) = holder {
+                if h == Holder::Player {
+                    m.extra.leash_player = Some(player_uuid);
+                }
                 m.extra.leash = Some(h);
                 m.extra.leash_pending = None;
             } else if m.age > 100 {
@@ -201,7 +204,9 @@ impl Game<'_> {
                 if self.mobs[index].extra.leash.is_some() {
                     self.break_leash(id, true, false);
                 }
+                let holder = self.acting_player_uuid();
                 self.mobs[index].extra.leash = Some(Holder::Player);
+                self.mobs[index].extra.leash_player = Some(holder);
                 self.lead_sound("tied", at);
                 // The lead is always used up.
                 if let Some(stack) = self.held_mut().as_mut() {
@@ -381,6 +386,8 @@ impl Game<'_> {
                                 layer: 0,
                                 color,
                                 light: packed,
+
+                                glint_uv: [0.0, 0.0],
                             });
                         }
                     }
diff --git a/crates/horizon-client/src/game/level_particles.rs b/crates/horizon-client/src/game/level_particles.rs
index f12aedc5b..7c6fb5598 100644
--- a/crates/horizon-client/src/game/level_particles.rs
+++ b/crates/horizon-client/src/game/level_particles.rs
@@ -1,21 +1,28 @@
 //! Level events whose client handler (`LevelEventHandler`) spawns particles
 //! on a block: bone meal's growth (1505), dragon egg teleportation (2015), a
 //! consumable's teleport (2017), electric sparks (3002), waxing (3003), wax
-//! off (3004) and scraping (3005).
+//! off (3004) and scraping (3005), plus the smoke, drips, egg and dragon
+//! fireball particles of 1501, 1502, 1504, 2006, 2009, 2012 and 3009.
 use super::Game;
+use horizon_client::items::ItemStack;
 use horizon_client::particles::{self, ParticleOptions, ParticleType};
-use horizon_core::{position::BlockPos, random::RandomSource};
+use horizon_core::{geometry::trig, position::BlockPos, random::RandomSource};
 use horizon_world::level::LevelEvent;
+use horizon_world::registry::BlockStateId;
 
 impl Game<'_> {
     pub(super) fn dragon_egg_particles(&mut self, pos: [i32; 3], data: i32) {
-        self.particles
-            .block_teleportation(pos, data, [16, 8, 16], self.settings.particles);
+        self.particles.block_teleportation(pos, data, [16, 8, 16]);
+    }
+    /// Event 2016: `Shulker.teleportSomewhere`'s particles between the
+    /// shell's old and new cells.
+    pub(super) fn shulker_teleport_particles(&mut self, pos: [i32; 3], data: i32) {
+        self.particles.block_teleportation(pos, data, [8, 8, 8]);
     }
     /// Event 2017: `TeleportRandomlyConsumeEffect`'s directional particles.
     pub(super) fn consume_teleport_particles(&mut self, pos: [i32; 3], data: i32) {
         self.particles
-            .block_teleportation(pos, data, [127, 127, 127], self.settings.particles);
+            .block_teleportation(pos, data, [127, 127, 127]);
     }
     /// `LevelEventHandler.levelEvent` 3002 to 3005, drawing from the client
     /// level's random.
@@ -65,24 +72,42 @@ impl Game<'_> {
                 } else {
                     // ParticleUtils.spawnParticleInBlock: up to the
                     // block's shape (a full block when air).
-                    let inside = self.world.block(at[0], at[1], at[2]);
-                    let height = if facts.is_air(inside) {
-                        1.0
-                    } else {
-                        facts
-                            .get(inside)
-                            .outline
-                            .iter()
-                            .map(|b| b[4])
-                            .fold(0.0, f64::max)
-                    };
-                    (at, count, 0.5, height, true)
+                    (at, count, 0.5, self.block_shape_top(at), true)
                 }
             }
             None if &*facts.get(state).name == "minecraft:water" => (p, count * 3, 3.0, 1.0, false),
             None => return,
         };
-        let options = ParticleOptions::simple(ParticleType::HappyVillager);
+        self.spawn_particles(at, count, xz, height, floating, ParticleType::HappyVillager);
+    }
+    /// `BlockState.getShape(..).max(Y)` of the block at `at`, 1.0 for air.
+    fn block_shape_top(&self, at: [i32; 3]) -> f64 {
+        let facts = self.res.facts();
+        let inside = self.world.block(at[0], at[1], at[2]);
+        if facts.is_air(inside) {
+            1.0
+        } else {
+            facts
+                .get(inside)
+                .outline
+                .iter()
+                .map(|b| b[4])
+                .fold(0.0, f64::max)
+        }
+    }
+    /// `ParticleUtils.spawnParticles`: `count` slow particles spread over
+    /// `xz` blocks around `at` and `height` up, only above solid ground
+    /// unless floating ones are allowed.
+    fn spawn_particles(
+        &mut self,
+        at: [i32; 3],
+        count: i32,
+        xz: f64,
+        height: f64,
+        floating: bool,
+        ty: ParticleType,
+    ) {
+        let options = ParticleOptions::simple(ty);
         for _ in 0..count.max(0) {
             let r = self.particles.level_random();
             let v = [0.0; 3].map(|_: f64| r.next_gaussian() * 0.02);
@@ -101,6 +126,161 @@ impl Game<'_> {
             }
         }
     }
+    /// `LevelEventHandler` 2012 (a turtle egg laid on sand):
+    /// `ParticleUtils.spawnParticleInBlock` with happy villager sparks.
+    pub(super) fn turtle_egg_particles(&mut self, pos: BlockPos, count: i32) {
+        let at = [pos.x, pos.y, pos.z];
+        let height = self.block_shape_top(at);
+        self.spawn_particles(at, count, 0.5, height, true, ParticleType::HappyVillager);
+    }
+    /// `LevelEventHandler` 3009 (a sniffer egg cracking on moss):
+    /// `spawnParticlesOnBlockFaces(.., EGG_CRACK, UniformInt.of(3, 6))`.
+    pub(super) fn sniffer_egg_crack_particles(&mut self, pos: BlockPos) {
+        let mut spawned = Vec::new();
+        particles::on_block_faces_between(
+            self.particles.level_random(),
+            [pos.x, pos.y, pos.z],
+            3,
+            6,
+            |p, v| spawned.push((p, v)),
+        );
+        let options = ParticleOptions::simple(ParticleType::EggCrack);
+        for (p, v) in spawned {
+            self.particles.add(&options, p, v);
+        }
+    }
+    /// `LevelEventHandler` 1501 (lava put out) and 2009 (a wet sponge dried):
+    /// eight puffs just above the block, drawn after the sound.
+    pub(super) fn puffs_above_block(&mut self, pos: BlockPos, ty: ParticleType) {
+        let options = ParticleOptions::simple(ty);
+        for _ in 0..8 {
+            let r = self.particles.level_random();
+            let x = f64::from(pos.x) + r.next_double();
+            let z = f64::from(pos.z) + r.next_double();
+            self.particles
+                .add(&options, [x, f64::from(pos.y) + 1.2, z], [0.0; 3]);
+        }
+    }
+    /// `LevelEventHandler` 1502 (a redstone torch burning out): five smoke
+    /// puffs inside the block, drawn after the sound.
+    pub(super) fn torch_burnout_smoke(&mut self, pos: BlockPos) {
+        let options = ParticleOptions::simple(ParticleType::Smoke);
+        for _ in 0..5 {
+            let r = self.particles.level_random();
+            let x = f64::from(pos.x) + r.next_double() * 0.6 + 0.2;
+            let y = f64::from(pos.y) + r.next_double() * 0.6 + 0.2;
+            let z = f64::from(pos.z) + r.next_double() * 0.6 + 0.2;
+            self.particles.add(&options, [x, y, z], [0.0; 3]);
+        }
+    }
+    /// `LevelEventHandler` 2006 (`DragonFireball.onHit`): 200 dragon breath
+    /// particles thrown outwards, then the explosion sound when `data` is 1.
+    pub(super) fn dragon_fireball_burst(&mut self, pos: BlockPos, data: i32) {
+        for _ in 0..200 {
+            let r = self.particles.level_random();
+            let dist = r.next_float() * 4.0;
+            let angle = r.next_float() * std::f32::consts::TAU;
+            let vx = f64::from(trig::cos(f64::from(angle)) * dist);
+            let vy = 0.01 + r.next_double() * 0.5;
+            let vz = f64::from(trig::sin(f64::from(angle)) * dist);
+            let options = ParticleOptions {
+                scale: dist,
+                ..ParticleOptions::simple(ParticleType::DragonBreath)
+            };
+            self.particles.add(
+                &options,
+                [
+                    f64::from(pos.x) + vx * 0.1,
+                    f64::from(pos.y) + 0.3,
+                    f64::from(pos.z) + vz * 0.1,
+                ],
+                [vx, vy, vz],
+            );
+        }
+        if data == 1 {
+            let at = [pos.x, pos.y, pos.z].map(|v| f64::from(v) + 0.5);
+            let pitch = self.world.random.next_float() * 0.1 + 0.9;
+            self.audio.play(
+                "minecraft:entity.dragon_fireball.explode",
+                Some(at),
+                1.0,
+                pitch,
+            );
+        }
+    }
+    /// `SpeleothemBlock.isStalactite`: a speleothem whose tip points down.
+    fn is_stalactite(&self, state: BlockStateId) -> bool {
+        self.res.facts().get(state).has_class("SpeleothemBlock")
+            && self
+                .pack
+                .assets
+                .registry
+                .state(state)
+                .and_then(|s| s.properties.get("vertical_direction"))
+                .is_some_and(|d| d == "down")
+    }
+    /// `LevelEventHandler` 1504: `PointedDripstoneBlock.spawnDripParticle` at
+    /// the tip `pos`. The fluid above the stalactite's root picks the drip;
+    /// with none, the dimension's default (lava in the Nether).
+    pub(super) fn dripstone_drip_particle(&mut self, pos: BlockPos) {
+        let tip_state = self.world.block(pos.x, pos.y, pos.z);
+        if !self.is_stalactite(tip_state) {
+            return;
+        }
+        // findRootBlock: up through the same stalactite, at most 11 steps.
+        let tip_name = self.res.facts().get(tip_state).name.clone();
+        let mut root = None;
+        for step in 1..11 {
+            let y = pos.y + step;
+            if !(horizon_client::chunk::MIN_Y
+                ..horizon_client::chunk::MIN_Y + horizon_client::chunk::HEIGHT)
+                .contains(&y)
+            {
+                break;
+            }
+            let state = self.world.block(pos.x, y, pos.z);
+            if self.res.facts().get(state).name != tip_name {
+                root = Some(y);
+                break;
+            }
+            if !self.is_stalactite(state) {
+                break;
+            }
+        }
+        let Some(root_y) = root else {
+            return;
+        };
+        let above = self.world.block(pos.x, root_y + 1, pos.z);
+        let above_facts = self.res.facts().get(above);
+        let nether = self.dim == super::Dim::Nether;
+        let fluid = if &*above_facts.name == "minecraft:mud" && !nether {
+            horizon_client::blocks::Fluid::Water
+        } else {
+            above_facts.fluid
+        };
+        let ty = match fluid {
+            horizon_client::blocks::Fluid::Water => ParticleType::DrippingDripstoneWater,
+            horizon_client::blocks::Fluid::Lava => ParticleType::DrippingDripstoneLava,
+            horizon_client::blocks::Fluid::None if nether => ParticleType::DrippingDripstoneLava,
+            horizon_client::blocks::Fluid::None => ParticleType::DrippingDripstoneWater,
+        };
+        let offset = self
+            .pack
+            .context
+            .tables
+            .offset(tip_state, pos.x, pos.z)
+            .unwrap_or([0.0; 3]);
+        // The tip shape starts 5/16 up; the particle sits a pixel below that.
+        self.particles.add(
+            &ParticleOptions::simple(ty),
+            [
+                f64::from(pos.x) + 0.5 + offset[0],
+                f64::from(pos.y) + 5.0 / 16.0 - 0.0625,
+                f64::from(pos.z) + 0.5 + offset[2],
+            ],
+            [0.0; 3],
+        );
+    }
     /// `ServerLevel.globalLevelEvent`: heard by every player on the server
     /// (an end portal opening, the dragon's death roar): here, and sent to
     /// every guest whatever their dimension.
@@ -134,6 +314,92 @@ impl Game<'_> {
         // Each guest plays it from the global packet.
         self.audio.play_unshared(sound, at, volume, 1.0);
     }
+    /// `ClientLevel.addBreakingBlockEffects`: the block's hit sound (only for
+    /// `play_sound`) and one crumb on the face being mined; nothing for air.
+    pub(super) fn breaking_block_effects(
+        &mut self,
+        pos: [i32; 3],
+        face: [i32; 3],
+        play_sound: bool,
+    ) {
+        let state = self.world.block(pos[0], pos[1], pos[2]);
+        if self.res.facts().is_air(state) {
+            return;
+        }
+        if play_sound {
+            let sounds = self.res.facts().get(state).sounds.clone();
+            // Each guest plays it from the level event itself.
+            self.audio.play_unshared(
+                &sounds.hit,
+                Some(pos.map(|v| f64::from(v) + 0.5)),
+                (sounds.volume + 1.0) / 8.0,
+                sounds.pitch * 0.5,
+            );
+        }
+        self.crack_particle(pos, face, state);
+    }
+    /// `LevelEventHandler.potionSplashParticles` (2002 with `Effect`, 2007
+    /// with `InstantEffect`): eight splash potion crumbs, and a hundred
+    /// spell particles in the potion's colour `data`, flung out in a disc.
+    pub(super) fn potion_splash_particles(&mut self, pos: BlockPos, data: i32, instant: bool) {
+        let ty = if instant {
+            ParticleType::InstantEffect
+        } else {
+            ParticleType::Effect
+        };
+        // Vec3.atBottomCenterOf.
+        let at = [
+            f64::from(pos.x) + 0.5,
+            f64::from(pos.y),
+            f64::from(pos.z) + 0.5,
+        ];
+        let crumb = self.item_particle(&ItemStack::new("minecraft:splash_potion", 1));
+        let r = self.particles.level_random();
+        let crumbs: Vec<[f64; 3]> = (0..8)
+            .map(|_| {
+                [
+                    r.next_gaussian() * 0.15,
+                    r.next_double() * 0.2,
+                    r.next_gaussian() * 0.15,
+                ]
+            })
+            .collect();
+        for v in crumbs {
+            self.particles.add(&crumb, at, v);
+        }
+        let channel = |shift: i32| ((data >> shift) & 0xFF) as f32 / 255.0;
+        let color = [channel(16), channel(8), channel(0)];
+        for _ in 0..100 {
+            let r = self.particles.level_random();
+            let dist = r.next_double() * 4.0;
+            let angle = r.next_double() * std::f64::consts::PI * 2.0;
+            let velocity = [
+                angle.cos() * dist,
+                0.01 + r.next_double() * 0.5,
+                angle.sin() * dist,
+            ];
+            let brightness = 0.75 + r.next_float() * 0.25;
+            let options = ParticleOptions {
+                color: [
+                    color[0] * brightness,
+                    color[1] * brightness,
+                    color[2] * brightness,
+                    1.0,
+                ],
+                scale: dist as f32,
+                ..ParticleOptions::simple(ty)
+            };
+            self.particles.add(
+                &options,
+                [
+                    at[0] + velocity[0] * 0.1,
+                    at[1] + 0.3,
+                    at[2] + velocity[2] * 0.1,
+                ],
+                velocity,
+            );
+        }
+    }
     /// Queue and play level event `id` at `pos` (`Level.levelEvent`).
     pub(super) fn level_event_at(&mut self, id: i32, pos: [i32; 3], data: i32) {
         self.level_events.push(LevelEvent::LevelEvent {
diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs
index 8d2e0a4a2..ab316c4c6 100644
--- a/crates/horizon-client/src/game/levels.rs
+++ b/crates/horizon-client/src/game/levels.rs
@@ -66,6 +66,8 @@ pub(super) struct Parked {
     tnts: Vec<tnt::PrimedTnt>,
     hoppers: HashMap<(i32, i32, i32), machines::HopperState>,
     mobs: Vec<Mob>,
+    /// The entity ids of the level's fence knots (`knot_ids`).
+    knot_ids: HashMap<[i32; 3], u32>,
     projectiles: Vec<horizon_client::projectiles::Projectile>,
     dropped: Vec<ItemEntity>,
     orbs: Vec<ExperienceOrb>,
@@ -75,7 +77,7 @@ pub(super) struct Parked {
     lan_events: Vec<(i32, [i32; 3], i32, Option<u32>)>,
     lan_block_events: Vec<([i32; 3], i32, i32, u32)>,
     lan_entity_events: Vec<(i32, i8, [f64; 3])>,
-    lan_critical_hits: Vec<(Option<u32>, i32)>,
+    lan_critical_hits: Vec<(Option<u32>, i32, bool)>,
     /// Only the per-level parts of these are used (`swap_level`).
     anims: BlockEntityAnims,
     raiding: Raiding,
@@ -109,6 +111,23 @@ pub(super) struct Levels {
     parked: HashMap<Dim, Parked>,
 }
 
+impl Levels {
+    /// The chunks of each level not in place (capability `world` lends
+    /// them to server mods for a call).
+    #[cfg_attr(not(feature = "mods"), allow(dead_code))]
+    pub(super) fn parked_chunks(
+        &mut self,
+    ) -> impl Iterator<Item = (Dim, &mut horizon_client::chunk_map::ChunkMap)> {
+        self.parked
+            .iter_mut()
+            .map(|(d, p)| (*d, &mut p.world.chunks))
+    }
+    /// The levels that are not in place, by dimension.
+    pub(super) fn parked_dims(&self) -> Vec<Dim> {
+        self.parked.keys().copied().collect()
+    }
+}
+
 impl Game<'_> {
     /// A new level for `dim`, opened from the save (`MinecraftServer.createLevels`).
     fn open_level(&self, dim: Dim) -> Result<Parked> {
@@ -153,6 +172,7 @@ impl Game<'_> {
             tnts: Vec::new(),
             hoppers: HashMap::new(),
             mobs: Vec::new(),
+            knot_ids: HashMap::new(),
             projectiles: Vec::new(),
             dropped: Vec::new(),
             orbs: Vec::new(),
@@ -179,6 +199,7 @@ impl Game<'_> {
         let mut locator = self.end.locator();
         swap(&mut locator, &mut p.locator);
         self.end.set_locator(locator);
+        self.share_spawn_conditions();
         swap(&mut self.save, &mut p.save);
         swap(&mut self.block_ticks, &mut p.block_ticks);
         swap(&mut self.tick_chunks, &mut p.tick_chunks);
@@ -205,6 +226,7 @@ impl Game<'_> {
         swap(&mut self.tnts, &mut p.tnts);
         swap(&mut self.hoppers, &mut p.hoppers);
         swap(&mut self.mobs, &mut p.mobs);
+        swap(&mut self.knot_ids, &mut p.knot_ids);
         swap(&mut self.creatures.projectiles, &mut p.projectiles);
         swap(&mut self.dropped, &mut p.dropped);
         swap(&mut self.orbs, &mut p.orbs);
@@ -225,6 +247,7 @@ impl Game<'_> {
         swap(&mut a.pots, &mut b.pots);
         swap(&mut a.gateways, &mut b.gateways);
         swap(&mut a.gateway_servers, &mut b.gateway_servers);
+        swap(&mut a.conduit_servers, &mut b.conduit_servers);
         self.raiding.swap_level(&mut p.raiding);
         self.sculk.swap_level(&mut p.sculk);
         self.creaking.swap_level(&mut p.creaking);
@@ -313,6 +336,8 @@ impl Game<'_> {
             };
             self.update_dedicated_streaming();
             self.update_world();
+            // What server mods set in this level since its last tick.
+            self.apply_mod_block_writes();
             result = if paused {
                 self.tick_lan(true);
                 Ok(())
@@ -383,7 +408,8 @@ impl Game<'_> {
         }
         *next += self.clock.tick_duration();
         if *next > now {
-            // A `/pregen` task keeps the workers fed until the next tick.
+            // A `/pregen` task or force-loaded chunks keep the workers fed
+            // until the next tick.
             self.pump_pregen(*next);
             let now = Instant::now();
             if *next > now {
diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs
index 297f372c5..921244e6d 100644
--- a/crates/horizon-client/src/game/lightning.rs
+++ b/crates/horizon-client/src/game/lightning.rs
@@ -16,7 +16,7 @@ pub(super) struct Bolt {
     flashes: i32,
     seed: i64,
     visual_only: bool,
-    /// Mooshrooms switch colour once per bolt.
+    /// Mooshrooms and copper golems change once per bolt.
     converted: Vec<u32>,
 }
 impl Game<'_> {
@@ -74,14 +74,74 @@ impl Game<'_> {
             self.spawn_bolt(at, trap);
         }
     }
-    /// `findLightningTargetAround`: a living entity under open sky in the
-    /// column (3 blocks around), else the top of the column.
+    /// `ServerLevel.findLightningRod`: `PoiManager.findClosest` over the
+    /// lightning rod points of interest within 128 blocks of `center` whose
+    /// block is the top (`WORLD_SURFACE`) of its column; the strike lands one
+    /// above it. Horizon keeps no point-of-interest index, so this scans the
+    /// loaded chunks the way `/locate poi` does.
+    fn find_lightning_rod(&self, center: [i32; 3]) -> Option<[i32; 3]> {
+        const RANGE: i32 = 128;
+        let facts = self.res.facts();
+        let mut is_rod: std::collections::HashMap<u32, bool> = std::collections::HashMap::new();
+        let mut best: Option<(i64, [i32; 3])> = None;
+        let (cx0, cz0) = ((center[0] - RANGE) >> 4, (center[2] - RANGE) >> 4);
+        let (cx1, cz1) = ((center[0] + RANGE) >> 4, (center[2] + RANGE) >> 4);
+        for cx in cx0..=cx1 {
+            for cz in cz0..=cz1 {
+                let Some(chunk) = self.world.chunks.get(&(cx, cz)) else {
+                    continue;
+                };
+                for (i, section) in chunk.sections.iter().enumerate() {
+                    let mut rod = |state: u32| {
+                        *is_rod.entry(state).or_insert_with(|| {
+                            facts
+                                .get(horizon_world::registry::BlockStateId(state))
+                                .name
+                                .ends_with("lightning_rod")
+                        })
+                    };
+                    if !section.blocks.maybe_has(&mut rod) {
+                        continue;
+                    }
+                    let base_y = horizon_client::chunk::MIN_Y + 16 * i as i32;
+                    for j in 0..4096 {
+                        if !rod(section.get(j)) {
+                            continue;
+                        }
+                        let p = [
+                            cx * 16 + (j & 15) as i32,
+                            base_y + (j >> 8) as i32,
+                            cz * 16 + ((j >> 4) & 15) as i32,
+                        ];
+                        let d = [p[0] - center[0], p[1] - center[1], p[2] - center[2]]
+                            .map(|d| i64::from(d) * i64::from(d))
+                            .iter()
+                            .sum::<i64>();
+                        if d > i64::from(RANGE * RANGE) || best.is_some_and(|(b, _)| d >= b) {
+                            continue;
+                        }
+                        let surface = self.world.world_surface(p[0], p[2], |s| facts.is_air(s));
+                        if p[1] == surface - 1 {
+                            best = Some((d, p));
+                        }
+                    }
+                }
+            }
+        }
+        best.map(|(_, p)| [p[0], p[1] + 1, p[2]])
+    }
+    /// `findLightningTargetAround`: the closest lightning rod, else a living
+    /// entity under open sky in the column (3 blocks around), else the top of
+    /// the column.
     fn lightning_target(&mut self, x: i32, z: i32) -> Option<[i32; 3]> {
         if !self.world.loaded(x, z) {
             return None;
         }
         let top =
             self.with_level(|b, level, _| b.motion_blocking_top(level, BlockPos::new(x, 0, z)));
+        if let Some(rod) = self.find_lightning_rod([x, top.y, z]) {
+            return Some(rod);
+        }
         let sees_sky = |g: &Self, p: [i32; 3]| g.world.light(p[0], p[1], p[2]) >> 4 == 15;
         let mut candidates: Vec<[i32; 3]> = self
             .mobs
@@ -218,6 +278,13 @@ impl Game<'_> {
                     }
                     self.strike_rod(b.at);
                 }
+                // LightningBolt.tick runs clearCopperOnLightningStrike for
+                // every server bolt, a skeleton trap's visual one included;
+                // a client's copy of a server bolt (spawn_remote_bolt) only
+                // flashes.
+                if self.remote.is_none() {
+                    self.bolt_clear_copper(b.at);
+                }
             }
             b.life -= 1;
             if b.life < 0 {
@@ -274,6 +341,16 @@ impl Game<'_> {
             self.level_event_at(3002, p, axis);
         }
     }
+    /// `LightningBolt.clearCopperOnLightningStrike` at the block the bolt struck.
+    fn bolt_clear_copper(&mut self, at: [f64; 3]) {
+        let p = BlockPos::new(
+            at[0].floor() as i32,
+            (at[1] - 1.0e-6).floor() as i32,
+            at[2].floor() as i32,
+        );
+        self.with_level(|b, level, ticks| b.lightning_clear_copper(level, ticks, p));
+        let _ = self.process_level_events();
+    }
     /// `thunderHit` for entities within 3 blocks (up to 9 above).
     fn thunder_hit(&mut self, b: &mut Bolt) {
         let at = b.at;
@@ -333,6 +410,17 @@ impl Game<'_> {
                     continue;
                 }
                 Species::Creeper => m.extra.charged = true,
+                // CopperGolem.thunderHit (after Entity.thunderHit's fire and
+                // damage): once per bolt, an oxidized golem goes back one step
+                // and its weathering timer (or wax, -2) is reset to -1.
+                Species::CopperGolem if !b.converted.contains(&m.id) => {
+                    b.converted.push(m.id);
+                    if m.extra.variant > 0 {
+                        m.extra.vector[0] = -1.0;
+                        m.extra.variant =
+                            horizon_client::mobs::copper_golem::weather_previous(m.extra.variant);
+                    }
+                }
                 _ => {}
             }
             // Entity.thunderHit: burning (8 seconds) and 5 lightning damage.
diff --git a/crates/horizon-client/src/game/llamas.rs b/crates/horizon-client/src/game/llamas.rs
index 1ce518f31..080343952 100644
--- a/crates/horizon-client/src/game/llamas.rs
+++ b/crates/horizon-client/src/game/llamas.rs
@@ -25,11 +25,13 @@ impl Game<'_> {
         };
         let m = &mut self.mobs[index];
         let mut used = false;
+        let mut loved = false;
         if item == "minecraft:hay_block" && m.extra.tame && m.extra.age == 0 && m.extra.in_love <= 0
         {
             m.extra.in_love = 600;
             m.extra.love_player = true;
             used = true;
+            loved = true;
         }
         if m.health < m.attrs.max_health {
             m.health = (m.health + heal).min(m.attrs.max_health);
@@ -57,6 +59,10 @@ impl Game<'_> {
         if !used {
             return false;
         }
+        // Animal.setInLove: entity event 18.
+        if loved {
+            self.mob_event_particles(self.mobs[index].id, 18);
+        }
         self.llama_sound(index, "entity.llama.eat", 1.0);
         self.consume_held();
         true
diff --git a/crates/horizon-client/src/game/mace.rs b/crates/horizon-client/src/game/mace.rs
index 8ad5e76c3..34c968980 100644
--- a/crates/horizon-client/src/game/mace.rs
+++ b/crates/horizon-client/src/game/mace.rs
@@ -24,7 +24,7 @@ const KNOCKBACK_POWER: f32 = 0.7;
 /// `Entity.isAlliedTo` between the player (`player` its UUID) and a mob
 /// without teams: `TamableAnimal.considersEntityAsAlly` (a pet it tamed) and
 /// `Allay.considersEntityAsAlly` (an allay that likes it).
-fn ally_of_player(m: &Mob, player: Option<[i32; 4]>) -> bool {
+pub(super) fn ally_of_player(m: &Mob, player: Option<[i32; 4]>) -> bool {
     let tamable = matches!(
         m.species(),
         Species::Wolf
diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs
index 8742962e9..78dbfe66b 100644
--- a/crates/horizon-client/src/game/machines.rs
+++ b/crates/horizon-client/src/game/machines.rs
@@ -159,8 +159,10 @@ impl Containers<'_> {
             });
         }
         let entity = self.world.block_entities.get(&pos)?;
-        // A beehive keeps bees, not items: it is no `Container`.
-        if matches!(entity, BlockEntity::Beehive(_)) {
+        // A beehive keeps bees, not items, and a campfire cooks its own: neither
+        // is a `Container` (HopperBlockEntity.getContainerAt), so a dropper drops
+        // in front of them and a hopper leaves them alone.
+        if matches!(entity, BlockEntity::Beehive(_) | BlockEntity::Campfire(_)) {
             return None;
         }
         let kind = match (entity, name) {
@@ -624,46 +626,8 @@ impl Game<'_> {
     /// `HopperBlockEntity.suckInItems`: from the container above, or item entities.
     fn hopper_suck(&mut self, pos: Pos, hopper: &View) -> bool {
         let above = (pos.0, pos.1 + 1, pos.2);
-        let c = self.containers();
-        if let Some(source) = c.view(above, false) {
-            if let Kind::Composter(level) = source.kind {
-                if level != 8 {
-                    return false;
-                }
-                // tryTakeInItemFromSlot on the OutputContainer: removeItem calls
-                // its setChanged, which empties the composter, and so does the
-                // second setChanged after the move or, when the hopper has no
-                // room, the setItem putting the bone meal back into the detached
-                // container (whose bone meal is lost with it).
-                let bone_meal = c.bone_meal.clone();
-                let at = BlockPos::new(above.0, above.1, above.2);
-                self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at));
-                let moved = self.add_item(None, hopper, bone_meal, None).is_none();
-                self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at));
-                self.world.modified.insert((above.0 >> 4, above.2 >> 4));
-                return moved;
-            }
-            let source_hopper = (source.kind == Kind::Hopper).then_some(above);
-            for slot in source.slots_for_face(Some(Direction::Down)) {
-                let c = self.containers();
-                let Some(stack) = c.get(&source, slot) else {
-                    continue;
-                };
-                if !c.can_take(&source, slot, stack, Direction::Down) {
-                    continue;
-                }
-                let Some(one) = self.take_one(&source, slot) else {
-                    continue;
-                };
-                match self.add_item(source_hopper, hopper, one, None) {
-                    None => {
-                        self.view_changed(&source);
-                        return true;
-                    }
-                    Some(rest) => self.put_back(&source, slot, rest),
-                }
-            }
-            return false;
+        if let Some(took) = self.suck_from_container(above, hopper) {
+            return took;
         }
         let above_state = self.world.block(above.0, above.1, above.2);
         let blocked = self.res.facts().get(above_state).full_collision
@@ -693,6 +657,56 @@ impl Game<'_> {
         {
             return false;
         }
+        self.suck_item_entities(hopper, min, max)
+    }
+    /// The container half of `HopperBlockEntity.suckInItems`: one item from the
+    /// container at `above`, through its bottom face. `None` when there is no
+    /// container there.
+    fn suck_from_container(&mut self, above: Pos, hopper: &View) -> Option<bool> {
+        let c = self.containers();
+        let source = c.view(above, false)?;
+        if let Kind::Composter(level) = source.kind {
+            if level != 8 {
+                return Some(false);
+            }
+            // tryTakeInItemFromSlot on the OutputContainer: removeItem calls
+            // its setChanged, which empties the composter, and so does the
+            // second setChanged after the move or, when the hopper has no
+            // room, the setItem putting the bone meal back into the detached
+            // container (whose bone meal is lost with it).
+            let bone_meal = c.bone_meal.clone();
+            let at = BlockPos::new(above.0, above.1, above.2);
+            self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at));
+            let moved = self.add_item(None, hopper, bone_meal, None).is_none();
+            self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at));
+            self.world.modified.insert((above.0 >> 4, above.2 >> 4));
+            return Some(moved);
+        }
+        let source_hopper = (source.kind == Kind::Hopper).then_some(above);
+        for slot in source.slots_for_face(Some(Direction::Down)) {
+            let c = self.containers();
+            let Some(stack) = c.get(&source, slot) else {
+                continue;
+            };
+            if !c.can_take(&source, slot, stack, Direction::Down) {
+                continue;
+            }
+            let Some(one) = self.take_one(&source, slot) else {
+                continue;
+            };
+            match self.add_item(source_hopper, hopper, one, None) {
+                None => {
+                    self.view_changed(&source);
+                    return Some(true);
+                }
+                Some(rest) => self.put_back(&source, slot, rest),
+            }
+        }
+        Some(false)
+    }
+    /// The item half of `HopperBlockEntity.suckInItems` (`getItemsAtAndAbove`):
+    /// adds the item entities that meet the box, until one is taken whole.
+    fn suck_item_entities(&mut self, hopper: &View, min: [f64; 3], max: [f64; 3]) -> bool {
         let mut i = 0;
         while i < self.dropped.len() {
             let b = self.dropped[i].bounds();
@@ -717,6 +731,66 @@ impl Game<'_> {
         }
         false
     }
+    /// `MinecartHopper.tick`'s `tryConsumeItems` (`suckInItems`) for an enabled
+    /// hopper minecart: one item from the container above, else the item
+    /// entities over it or touching it, each tick without a cooldown.
+    pub(super) fn hopper_cart_suck(&mut self, cart: &mut super::minecarts::Minecart) {
+        // The cart's slots are edited as a container under the placeholder key
+        // its menu uses; when that menu is open the placeholder is the live copy.
+        let key = (i32::MAX - 15, super::minecarts::CART_KEY_Y, cart.id as i32);
+        let open = self.world.block_entities.contains_key(&key);
+        if !open {
+            let items = BlockEntity::Chest(std::mem::take(&mut cart.items));
+            self.world.block_entities.insert(key, items);
+        }
+        let size = self
+            .world
+            .block_entities
+            .get(&key)
+            .map_or(0, |e| e.slots().len());
+        let view = View {
+            parts: vec![(key, size)],
+            kind: Kind::Generic,
+        };
+        let p = cart.position;
+        // getLevelY is the cart's y + 0.5, so the container is the block at
+        // y + 1.5, and Hopper.SUCK_AABB (moved by getLevel - 0.5) starts 11/16
+        // above the cart.
+        let above = (
+            p.x.floor() as i32,
+            (p.y + 1.5).floor() as i32,
+            p.z.floor() as i32,
+        );
+        let took = match self.suck_from_container(above, &view) {
+            Some(took) => took,
+            None => self.suck_item_entities(
+                &view,
+                [p.x - 0.5, p.y + 11.0 / 16.0, p.z - 0.5],
+                [p.x + 0.5, p.y + 2.0, p.z + 0.5],
+            ),
+        };
+        if !took {
+            // The cart's own box, inflated by 0.25 sideways.
+            let b = cart.bounds();
+            let (lo, hi) = (b.min_position(), b.max_position());
+            self.suck_item_entities(
+                &view,
+                [lo.x - 0.25, lo.y, lo.z - 0.25],
+                [hi.x + 0.25, hi.y, hi.z + 0.25],
+            );
+        }
+        // The cart's own items stay the one source of truth: a menu copy that
+        // is still around (open, or left by a guest's close) gets the pulled
+        // items back into `cart.items`, so reopening never restores a stale copy.
+        let slots = if open {
+            self.world.block_entities.get(&key).cloned()
+        } else {
+            self.world.block_entities.remove(&key)
+        };
+        if let Some(BlockEntity::Chest(items)) = slots {
+            cart.items = items;
+        }
+    }
 
     // ---- dispensers and droppers ----
 
diff --git a/crates/horizon-client/src/game/maps.rs b/crates/horizon-client/src/game/maps.rs
index 6da65c592..1617eab56 100644
--- a/crates/horizon-client/src/game/maps.rs
+++ b/crates/horizon-client/src/game/maps.rs
@@ -324,6 +324,13 @@ const DECORATION_TYPES: [(&str, &str); 24] = [
     ("mineshaft", "map/decorations/mineshaft"),
     ("ocean_ruin_warm", "map/decorations/warm_ocean_ruins"),
 ];
+/// `MapDecorationType.showOnItemFrame` is false for the player arrows and the two markers.
+fn shown_on_frame(sprite: &str) -> bool {
+    !matches!(
+        decoration_type(sprite),
+        Some("player" | "red_marker" | "blue_marker" | "player_off_map" | "player_off_limits")
+    )
+}
 /// The sprite of a decoration type that a `minecraft:map_decorations`
 /// entry or a server's packet names.
 fn decoration_sprite(id: &str) -> Option<&'static str> {
@@ -1114,9 +1121,12 @@ impl Game<'_> {
     }
     /// `MapRenderer.render`: the map texture and its decorations under `m`
     /// (map pixels 0..128, y down), drawn at depth offsets toward the viewer.
+    /// `show_only_frame` (a map in an item frame) leaves out the decorations that
+    /// do not show on frames.
     pub(super) fn map_vertices(
         &mut self,
         id: i32,
+        show_only_frame: bool,
         m: glam::Mat4,
         light: u32,
         out: &mut Vec<Vertex>,
@@ -1133,6 +1143,8 @@ impl Game<'_> {
                     layer: 0,
                     color: 0xFFFF_FFFF,
                     light,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         };
@@ -1158,14 +1170,18 @@ impl Game<'_> {
             .get(&id)
             .map(|m| m.decorations.clone())
             .unwrap_or_default();
-        for (i, d) in decorations.iter().enumerate() {
+        let mut count = 0;
+        for d in &decorations {
+            if show_only_frame && !shown_on_frame(d.sprite) {
+                continue;
+            }
             let Some(s) = self.gui.atlas.sprites.get(d.sprite).copied() else {
                 continue;
             };
             let dm = glam::Mat4::from_translation(glam::Vec3::new(
                 f32::from(d.x) / 2.0 + 64.0,
                 f32::from(d.y) / 2.0 + 64.0,
-                -0.02 - i as f32 * 0.001,
+                -0.02 - count as f32 * 0.001,
             )) * glam::Mat4::from_rotation_z(
                 (f32::from(d.rot) * 360.0 / 16.0).to_radians(),
             ) * glam::Mat4::from_scale(glam::Vec3::splat(4.0))
@@ -1180,6 +1196,8 @@ impl Game<'_> {
                         layer: 0,
                         color: 0xFFFF_FFFF,
                         light,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             };
@@ -1187,6 +1205,7 @@ impl Game<'_> {
                 [p(-1.0, 1.0), p(1.0, 1.0), p(1.0, -1.0), p(-1.0, -1.0)],
                 [[s.u0, s.v0], [s.u1, s.v0], [s.u1, s.v1], [s.u0, s.v1]],
             );
+            count += 1;
         }
     }
     /// `renderTwoHandedMap`: map `id` held in both hands, in view space (the
@@ -1251,11 +1270,13 @@ impl Game<'_> {
                     layer: 0,
                     color: 0xFFFF_FFFF,
                     light,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
         if has_data {
-            self.map_vertices(id, m, light, out);
+            self.map_vertices(id, false, m, light, out);
         }
     }
 }
diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index 072059e49..9dead141c 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -9,7 +9,7 @@ use horizon_client::{
     blocks::Fluid,
     collisions::SceneCollisions,
     containers::BlockEntity,
-    items::ItemStack,
+    items::{ItemStack, Items},
     mesher::Vertex,
     mobs::{Part, anim::Poses},
     particles::{ParticleOptions, ParticleType},
@@ -73,7 +73,7 @@ pub(super) struct Minecart {
     pub yaw: f32,
     pub previous_yaw: f32,
     pub flipped: bool,
-    on_ground: bool,
+    pub(super) on_ground: bool,
     horizontal_collision: bool,
     fall_distance: f64,
     pub hurt_time: i32,
@@ -90,6 +90,8 @@ pub(super) struct Minecart {
     /// Chest minecarts: the loot table rolled into `items` on load, saved
     /// again while the items are still that roll.
     pub loot: Option<horizon_client::save::RolledLoot>,
+    /// `Entity.firstTick`: not ticked yet (saved as `HasTicked`).
+    pub first_tick: bool,
 }
 pub(super) const WIDTH: f64 = 0.98;
 pub(super) const HEIGHT: f64 = 0.7;
@@ -186,6 +188,7 @@ impl Minecart {
             fuse: -1,
             enabled: true,
             loot: None,
+            first_tick: true,
         }
     }
     pub fn bounds(&self) -> Aabb {
@@ -198,6 +201,17 @@ impl Minecart {
     fn horizontal(&self) -> f64 {
         self.velocity.x.hypot(self.velocity.z)
     }
+    /// `AbstractContainerMenu.getRedstoneSignalFromContainer` of `slots`.
+    fn container_signal(slots: &[Option<ItemStack>], items: &Items) -> i32 {
+        let mut total = 0.0f32;
+        for s in slots.iter().flatten() {
+            let max = items.get(&s.item).map_or(64, |i| i.max_stack).min(64);
+            total += s.count as f32 / max as f32;
+        }
+        total /= slots.len().max(1) as f32;
+        // Mth.lerpDiscrete(total, 0, 15)
+        (total * 14.0).floor() as i32 + i32::from(total > 0.0)
+    }
 }
 pub(super) struct CartModels {
     pub models: HashMap<CartKind, Part>,
@@ -536,6 +550,7 @@ impl Game<'_> {
     }
     /// `AbstractMinecart.tick` for one cart; returns false once it is gone.
     fn tick_cart(&mut self, c: &mut Minecart, intent: [f64; 2]) -> bool {
+        c.first_tick = false;
         c.previous = c.position;
         c.previous_yaw = c.yaw;
         c.hurt_time = (c.hurt_time - 1).max(0);
@@ -543,7 +558,6 @@ impl Game<'_> {
         // applyGravity
         c.velocity.y -= if self.cart_in_water(c) { 0.005 } else { 0.04 };
         let pos = self.rail_block(c.position);
-        let fall_speed = c.velocity;
         if let Some(rail) = self.rail(pos[0], pos[1], pos[2]) {
             self.move_along_track(c, pos, &rail, intent);
             if &*rail.name == "minecraft:activator_rail" {
@@ -585,22 +599,26 @@ impl Game<'_> {
                 }
             }
             CartKind::Tnt => {
-                let speed = fall_speed.x * fall_speed.x + fall_speed.z * fall_speed.z;
+                // MinecartTNT.tick: the fuse and the collision check are separate.
                 if c.fuse > 0 {
                     c.fuse -= 1;
                     let at = [c.position.x, c.position.y + 0.5, c.position.z];
                     self.particles
                         .add(&ParticleOptions::simple(ParticleType::Smoke), at, [0.0; 3]);
-                } else if c.fuse == 0 || (c.horizontal_collision && speed >= 0.01) {
+                } else if c.fuse == 0 {
+                    // explode(horizontalDistanceSqr()): a rising cart's
+                    // vertical speed adds nothing.
                     let speed = c.velocity.x * c.velocity.x + c.velocity.z * c.velocity.z;
-                    let speed = if c.fuse == 0 && c.velocity.y > 0.0 {
-                        c.velocity.y * c.velocity.y
-                    } else {
-                        speed
-                    };
                     self.explode_cart(c, speed);
                     return false;
                 }
+                if c.horizontal_collision {
+                    let speed = c.velocity.x * c.velocity.x + c.velocity.z * c.velocity.z;
+                    if speed >= f64::from(0.01_f32) {
+                        self.explode_cart(c, speed);
+                        return false;
+                    }
+                }
             }
             _ => {}
         }
@@ -644,51 +662,9 @@ impl Game<'_> {
         // The cart is the explosion's source: it is gone before the blast
         // looks for entities, so it can't hit itself.
         self.carts.retain(|x| x.id != c.id);
-        let _ = self.server_explode(at, power, BlockInteraction::Destroy, false);
-    }
-    /// `MinecartHopper.suckInItems`: items above, into the five slots.
-    fn hopper_cart_pickup(&mut self, c: &mut Minecart) {
-        if !c.enabled {
-            return;
-        }
-        let p = c.position;
-        let zone = Aabb::new(
-            Vec3::new(p.x - 0.5, p.y - 0.5 + 0.0, p.z - 0.5),
-            Vec3::new(p.x + 0.5, p.y + 1.5, p.z + 0.5),
-        );
-        let mut i = 0;
-        while i < self.dropped.len() {
-            let e = &self.dropped[i];
-            if e.pickup_delay > 0 || !zone.contains(e.position) {
-                i += 1;
-                continue;
-            }
-            let mut stack = e.stack.clone();
-            for slot in c.items.iter_mut() {
-                match slot {
-                    None => {
-                        *slot = Some(stack.clone());
-                        stack.count = 0;
-                    }
-                    Some(s) if s.same_item_same_components(&stack) => {
-                        let max = self.res.items().get(&s.item).map_or(64, |i| i.max_stack);
-                        let moved = stack.count.min(max.saturating_sub(s.count));
-                        s.count += moved;
-                        stack.count -= moved;
-                    }
-                    _ => {}
-                }
-                if stack.count == 0 {
-                    break;
-                }
-            }
-            if stack.count == 0 {
-                self.dropped.remove(i);
-            } else {
-                self.dropped[i].stack = stack;
-                i += 1;
-            }
-        }
+        let _ = self.with_hive_emptying_blast(|g| {
+            g.server_explode(at, power, BlockInteraction::Destroy, false)
+        });
     }
     /// `AbstractMinecart.push` from each player walking into a cart
     /// (`LivingEntity.pushEntities`): the window's player and every server
@@ -713,12 +689,7 @@ impl Game<'_> {
                 host.hub.here(g) && g.loaded && !g.dead && !g.spectator() && g.vehicle.is_none()
             }) {
                 let [x, y, z] = g.position;
-                let height = if g.sneaking { 1.5 } else { 1.8 };
-                let bb = Aabb::new(
-                    Vec3::new(x - 0.3, y, z - 0.3),
-                    Vec3::new(x + 0.3, y + height, z + 0.3),
-                );
-                pushers.push((Vec3::new(x, y, z), bb));
+                pushers.push((Vec3::new(x, y, z), g.bounds()));
             }
         }
         for (feet, bb) in pushers {
@@ -827,8 +798,8 @@ impl Game<'_> {
             }
             let mut c = self.carts[i].clone();
             let alive = self.tick_cart(&mut c, [0.0; 2]);
-            if c.kind == CartKind::Hopper {
-                self.hopper_cart_pickup(&mut c);
+            if c.kind == CartKind::Hopper && c.enabled {
+                self.hopper_cart_suck(&mut c);
             }
             let Some(i) = self.carts.iter().position(|c| c.id == id) else {
                 continue;
@@ -946,7 +917,7 @@ impl Game<'_> {
         }
         true
     }
-    /// `getDismountLocationForPassenger`: beside the cart (across its motion), else on top.
+    /// `getDismountLocationForPassenger`: beside the cart (across its facing), else on top.
     pub(super) fn dismount_cart(&mut self, i: usize) {
         self.riding = None;
         let c = &self.carts[i];
@@ -956,17 +927,25 @@ impl Game<'_> {
             c.position.z.floor() as i32,
         );
         let mut target = None;
+        // DismountHelper.offsetsForDirection of the cart's facing
+        // (Direction.fromYRot of its yaw): right, left, back right, back left,
+        // forward right, forward left, back, forward.
+        let step = |q: i32| [(0, 1), (-1, 0), (0, -1), (1, 0)][(q & 3) as usize];
+        let facing = (f64::from(c.yaw) / 90.0 + 0.5).floor() as i32;
+        let (fx, fz) = step(facing);
+        let (rx, rz) = (-fz, fx);
+        let offsets = [
+            (rx, rz),
+            (-rx, -rz),
+            (rx - fx, rz - fz),
+            (-rx - fx, -rz - fz),
+            (fx + rx, fz + rz),
+            (fx - rx, fz - rz),
+            (-fx, -fz),
+            (fx, fz),
+        ];
         'search: for dy in [0, 1, -1] {
-            for (dx, dz) in [
-                (1, 0),
-                (-1, 0),
-                (0, 1),
-                (0, -1),
-                (1, 1),
-                (-1, -1),
-                (1, -1),
-                (-1, 1),
-            ] {
+            for (dx, dz) in offsets {
                 let (x, y, z) = (bx + dx, by + dy, bz + dz);
                 let below = self.res.facts().get(self.world.block(x, y - 1, z));
                 let here = self.res.facts().get(self.world.block(x, y, z));
@@ -1050,6 +1029,22 @@ impl Game<'_> {
         }
         best
     }
+    /// Each cart's kind and comparator signal, for the detector rail
+    /// (`DetectorRailBlock.getAnalogOutputSignal`). A cart whose menu is open
+    /// counts the items in that menu.
+    pub(super) fn cart_signals(&self) -> Vec<(CartKind, i32)> {
+        self.carts
+            .iter()
+            .map(|c| {
+                let key = (i32::MAX - 15, CART_KEY_Y, c.id as i32);
+                let slots = match self.world.block_entities.get(&key) {
+                    Some(BlockEntity::Chest(open)) => open,
+                    _ => &c.items,
+                };
+                (c.kind, Minecart::container_signal(slots, self.res.items()))
+            })
+            .collect()
+    }
     /// `interact`: ride, open, fuel or ignite the cart under the crosshair.
     pub(super) fn interact_cart(&mut self) -> bool {
         let Some((i, d)) = self.cart_hit() else {
@@ -1067,10 +1062,8 @@ impl Game<'_> {
                 }
                 self.riding = Some(self.carts[i].id);
             }
+            // AbstractMinecartContainer.interact: no sneak check.
             CartKind::Chest | CartKind::Hopper => {
-                if sneaking {
-                    return false;
-                }
                 let c = self.carts[i].clone();
                 let key = (i32::MAX - 15, CART_KEY_Y, c.id as i32);
                 self.world
@@ -1297,6 +1290,7 @@ impl Game<'_> {
                         layer: 0,
                         color,
                         light,
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
@@ -1340,9 +1334,8 @@ impl Game<'_> {
             return;
         };
         // Entity.shouldRenderAtSqrDistance: 64 times the bounding box's mean
-        // edge, scaled by the entity distance option.
-        let range =
-            (WIDTH + HEIGHT + WIDTH) / 3.0 * 64.0 * f64::from(self.settings.entity_distance);
+        // edge, scaled by the view scale.
+        let range = (WIDTH + HEIGHT + WIDTH) / 3.0 * 64.0 * self.view_scale();
         for c in &self.carts {
             let entity_start = out.len();
             let Some(model) = self.cart_models.models.get(&c.kind) else {
@@ -1509,6 +1502,10 @@ impl Minecart {
                 map.insert(JavaString::from(k), v);
             };
             put("FlippedRotation", Tag::Byte(i8::from(self.flipped)));
+            // AbstractMinecart saves firstTick as HasTicked. A cart never burns:
+            // Entity.move sets -getFireImmuneTicks(), 0 for all but players.
+            put("HasTicked", Tag::Byte(i8::from(self.first_tick)));
+            put("Fire", Tag::Short(0));
             match self.kind {
                 CartKind::Chest | CartKind::Hopper => {
                     put("Items", horizon_client::save::encode_items(&self.items));
@@ -1558,6 +1555,7 @@ impl Minecart {
             _ => 0.0,
         };
         c.flipped = int("FlippedRotation").unwrap_or(0) != 0;
+        c.first_tick = int("HasTicked").unwrap_or(0) != 0;
         if kind.slots() > 0 {
             c.items = horizon_client::save::decode_items(tag.get("Items"), kind.slots());
         }
@@ -1582,4 +1580,30 @@ mod tests {
         assert_eq!(display_offset(CartKind::CommandBlock), 6.0);
         assert_eq!(display_offset(CartKind::Rideable), 6.0);
     }
+
+    #[test]
+    fn a_cart_saves_as_never_ticked_until_it_ticks() {
+        use horizon_world::nbt::Tag;
+        let generated = Tag::compound([
+            ("id", Tag::String("minecraft:chest_minecart".into())),
+            (
+                "Pos",
+                Tag::List(
+                    [0.5f64, 40.5, 0.5]
+                        .map(|v| Tag::Double(v.to_bits()))
+                        .to_vec(),
+                ),
+            ),
+            ("HasTicked", Tag::Byte(1)),
+            ("Fire", Tag::Short(0)),
+        ]);
+        let mut cart = Minecart::from_nbt(&generated, 1, CartKind::Chest).unwrap();
+        let saved = cart.to_nbt([0; 4], Some(&generated));
+        assert_eq!(saved.get("HasTicked"), Some(&Tag::Byte(1)));
+        assert_eq!(saved.get("Fire"), Some(&Tag::Short(0)));
+        cart.first_tick = false;
+        let saved = cart.to_nbt([0; 4], Some(&generated));
+        assert_eq!(saved.get("HasTicked"), Some(&Tag::Byte(0)));
+        assert_eq!(saved.get("Fire"), Some(&Tag::Short(0)));
+    }
 }
diff --git a/crates/horizon-client/src/game/mob_blocks.rs b/crates/horizon-client/src/game/mob_blocks.rs
index 083c96a66..a57accfaa 100644
--- a/crates/horizon-client/src/game/mob_blocks.rs
+++ b/crates/horizon-client/src/game/mob_blocks.rs
@@ -1,6 +1,7 @@
 //! Blocks mobs carry: block items in a hand (`ItemInHandLayer`) and the
 //! block an enderman holds (`CarriedBlockLayer`), drawn as shaded cubes like
-//! dropped block items.
+//! dropped block items. Also the block models mobs wear (`SnowGolemHeadLayer`,
+//! `MushroomCowMushroomLayer`).
 use super::Game;
 use horizon_client::{
     items::ItemStack,
@@ -203,6 +204,8 @@ impl Game<'_> {
                     layer: overlay,
                     color,
                     light,
+
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
@@ -218,6 +221,7 @@ impl Game<'_> {
     ) {
         self.captain_banner_geometry(mob, camera, alpha, light, out);
         self.held_item_geometry(mob, camera, alpha, light, true, out);
+        self.worn_block_geometry(mob, camera, alpha, light, out);
         if mob.species() == Species::Enderman
             && let Some(state) = mob.extra.carried
             && let Some((sprite, tint)) = self.block_face_sprite(state)
@@ -244,6 +248,76 @@ impl Game<'_> {
             );
         }
     }
+    /// `SnowGolemHeadLayer` and `MushroomCowMushroomLayer`: the carved pumpkin
+    /// on a snow golem's head, and the mushrooms on an adult mooshroom's back
+    /// and head, as baked block models.
+    fn worn_block_geometry(
+        &self,
+        mob: &Mob,
+        camera: glam::DVec3,
+        alpha: f64,
+        light: u32,
+        out: &mut Vec<Vertex>,
+    ) {
+        use glam::{Mat4, Vec3};
+        let species = mob.species();
+        let on_head = match species {
+            Species::SnowGolem => !mob.extra.sheared,
+            Species::Mooshroom => !mob.is_baby(),
+            _ => false,
+        };
+        // The layers draw nothing on an invisible mob (the glow outline is not drawn).
+        if !on_head || horizon_client::mobs::trader::is_invisible(mob) {
+            return;
+        }
+        let registry = &self.pack.assets.registry;
+        let block = match species {
+            Species::SnowGolem => "minecraft:carved_pumpkin",
+            _ if mob.extra.variant == 1 => "minecraft:brown_mushroom",
+            _ => "minecraft:red_mushroom",
+        };
+        let Some(state) = registry.default_state(block) else {
+            return;
+        };
+        let alpha = alpha as f32;
+        let Some(head) = render::part_transform(mob, alpha, camera, self.res.mob_data(), "head")
+        else {
+            return;
+        };
+        let unit = Mat4::from_translation(Vec3::splat(-0.5));
+        let flip = Mat4::from_scale(Vec3::new(-1.0, -1.0, 1.0));
+        let at = |x: f32, y: f32, z: f32| Mat4::from_translation(Vec3::new(x, y, z));
+        let spin = |degrees: f32| Mat4::from_rotation_y(degrees.to_radians());
+        let transforms = if species == Species::SnowGolem {
+            vec![
+                head * at(0.0, -0.34375, 0.0)
+                    * spin(180.0)
+                    * Mat4::from_scale(Vec3::new(0.625, -0.625, -0.625))
+                    * unit,
+            ]
+        } else {
+            let base = render::base_transform(mob, alpha, camera);
+            vec![
+                base * at(0.2, -0.35, 0.5) * spin(-48.0) * flip * unit,
+                base * at(0.2, -0.35, 0.5)
+                    * spin(42.0)
+                    * at(0.1, 0.0, -0.6)
+                    * spin(-48.0)
+                    * flip
+                    * unit,
+                head * at(0.0, -0.7, -0.2) * spin(-78.0) * flip * unit,
+            ]
+        };
+        // The hurt tint reaches these blocks as it does the body.
+        let overlay = horizon_client::overlay::living(0.0, mob.hurt_time > 0 || mob.death_time > 0);
+        for t in transforms {
+            let start = out.len();
+            self.block_model_vertices(state, 0, t, light, true, out);
+            for vertex in &mut out[start..] {
+                vertex.layer = overlay;
+            }
+        }
+    }
     /// `ItemInHandLayer`: both hands through the item model pipeline; `lit`
     /// applies the level's diffuse lighting (off for GUI previews, which
     /// light the projected quads themselves).
diff --git a/crates/horizon-client/src/game/mod_browser.rs b/crates/horizon-client/src/game/mod_browser.rs
new file mode 100644
index 000000000..645415ccb
--- /dev/null
+++ b/crates/horizon-client/src/game/mod_browser.rs
@@ -0,0 +1,485 @@
+//! Capability `ui`'s panel beside container screens (WIT `interface
+//! browser`, docs/mods.md): the items a recipe viewer mod lists, drawn as
+//! the game's own item slots in pages right of the screen's window, with a
+//! search box under them. The mod says what the panel holds; the game pages
+//! it and tells the mod what the player clicked, typed, and which of the
+//! mod's keys went down over an item. With no mod showing a panel, each
+//! hook here returns after one check.
+use super::Game;
+#[cfg(feature = "mods")]
+use {
+    super::Screen,
+    horizon_client::{
+        hud::{HudBatch, rgba},
+        items::ItemStack,
+        ui::EditBox,
+    },
+    horizon_mods::{BrowserClick, BrowserEvent, BrowserStack},
+};
+
+#[cfg(not(feature = "mods"))]
+impl Game<'_> {
+    pub(super) fn draw_mod_browser(&mut self, _batch: &mut horizon_client::hud::HudBatch) {}
+    pub(super) fn mod_browser_press(&mut self, _right: bool) -> bool {
+        false
+    }
+    pub(super) fn mod_browser_typing(&self) -> bool {
+        false
+    }
+    pub(super) fn mod_browser_key(&mut self, _event: &winit::event::KeyEvent) {}
+    pub(super) fn mod_browser_text(&mut self, _text: Option<&str>, _backspace: bool) {}
+    pub(super) fn mod_browser_closed(&mut self) {}
+}
+
+/// One slot of the panel, in GUI pixels.
+#[cfg(feature = "mods")]
+const SLOT: f32 = 18.0;
+/// The most columns the panel takes, and the fewest it shows with.
+#[cfg(feature = "mods")]
+const COLUMNS: (usize, usize) = (12, 2);
+/// The gap between the window and the panel, and the screen's edges.
+#[cfg(feature = "mods")]
+const MARGIN: f32 = 8.0;
+
+/// The panel's state in the game.
+#[cfg(feature = "mods")]
+#[derive(Default)]
+pub(super) struct Browser {
+    /// The items' owner and version they were made from.
+    of: Option<(usize, u64)>,
+    /// The mod's items as stacks; `None` for an item the game doesn't have.
+    stacks: Vec<Option<ItemStack>>,
+    page: usize,
+    search: Option<EditBox>,
+    /// The search text the mod last heard.
+    sent: String,
+    /// `set-recipes`' recipes, shown instead of the items.
+    pub(super) recipes: Option<super::mod_browser_recipes::Pages>,
+}
+
+/// Where the panel's parts are this frame.
+#[cfg(feature = "mods")]
+pub(super) struct Layout {
+    /// The panel's whole area, for clicks that hit none of its parts.
+    pub(super) area: [f32; 4],
+    /// The grid's top left corner, its columns and rows.
+    pub(super) grid: (f32, f32),
+    pub(super) columns: usize,
+    pub(super) rows: usize,
+    /// The page arrows' row.
+    pub(super) arrows_y: f32,
+    pub(super) search: [f32; 4],
+}
+#[cfg(feature = "mods")]
+impl Layout {
+    fn per_page(&self) -> usize {
+        self.columns * self.rows
+    }
+    pub(super) fn width(&self) -> f32 {
+        self.columns as f32 * SLOT
+    }
+    fn slot(&self, n: usize) -> (f32, f32) {
+        (
+            self.grid.0 + (n % self.columns) as f32 * SLOT,
+            self.grid.1 + (n / self.columns) as f32 * SLOT,
+        )
+    }
+    /// The page arrows: backward, then forward.
+    pub(super) fn arrows(&self) -> [(f32, f32); 2] {
+        [
+            (self.grid.0, self.arrows_y),
+            (self.grid.0 + self.width() - 12.0, self.arrows_y),
+        ]
+    }
+}
+
+#[cfg(feature = "mods")]
+pub(super) fn inside(p: (f32, f32), [x, y, w, h]: [f32; 4]) -> bool {
+    p.0 >= x && p.1 >= y && p.0 < x + w && p.1 < y + h
+}
+
+#[cfg(feature = "mods")]
+impl Game<'_> {
+    fn browser_batch(&self) -> Option<HudBatch> {
+        let r = self.renderer.as_ref()?;
+        Some(HudBatch::new([r.config.width, r.config.height]))
+    }
+    /// The mod showing a panel, with its items made into stacks once per
+    /// `set-items`; none while no mod shows one or no container screen is up.
+    fn browser_sync(&mut self) -> Option<usize> {
+        if self.screen != Screen::Inventory || self.title.is_some() {
+            return None;
+        }
+        let Some((owner, version)) = self.mods.mods.browser_items().map(|(o, v, _)| (o, v)) else {
+            self.mods.browser.of = None;
+            self.mods.browser.stacks.clear();
+            return None;
+        };
+        if self.mods.browser.of != Some((owner, version)) {
+            let items = self.res.items();
+            let stacks = self
+                .mods
+                .mods
+                .browser_items()
+                .map_or_else(Vec::new, |(_, _, list)| {
+                    list.iter().map(|s| browser_stack(items, s)).collect()
+                });
+            self.mods.browser.stacks = stacks;
+            // The same title again (the mod updating its buttons) keeps the page.
+            let old = self.mods.browser.recipes.take();
+            self.mods.browser.recipes = self
+                .mods
+                .mods
+                .browser_recipes(owner)
+                .map(|shown| super::mod_browser_recipes::Pages::new(items, shown, old));
+            self.mods.browser.of = Some((owner, version));
+        }
+        Some(owner)
+    }
+    /// The panel's parts: right of the window, from the top of the screen to
+    /// the search box at its foot. None when the screen has no room for it.
+    fn browser_layout(&self, batch: &HudBatch) -> Option<Layout> {
+        let image = self.container_image(batch);
+        let left = (image.left + image.width) as f32 + MARGIN;
+        let right = batch.width - MARGIN;
+        let columns = (((right - left) / SLOT).floor().max(0.0) as usize).min(COLUMNS.0);
+        if columns < COLUMNS.1 {
+            return None;
+        }
+        let x = (left + (right - left - columns as f32 * SLOT) / 2.0).floor();
+        let arrows_y = MARGIN;
+        let top = arrows_y + 17.0 + 4.0;
+        let search = [x, batch.height - MARGIN - 16.0, columns as f32 * SLOT, 16.0];
+        let rows = ((search[1] - 4.0 - top) / SLOT).floor().max(0.0) as usize;
+        (rows > 0).then_some(Layout {
+            area: [left, 0.0, right - left, batch.height],
+            grid: (x, top),
+            columns,
+            rows,
+            arrows_y,
+            search,
+        })
+    }
+    fn browser_pages(&self, layout: &Layout) -> usize {
+        self.mods
+            .browser
+            .stacks
+            .len()
+            .div_ceil(layout.per_page())
+            .max(1)
+    }
+    /// The stack under the pointer on the panel, an item's or a recipe's,
+    /// as the mod sent it and as a stack.
+    fn browser_pointed_stack(&self, layout: &Layout) -> Option<(BrowserStack, ItemStack)> {
+        if self.mods.browser.recipes.is_some() {
+            if let Some((_, sent, stack)) = self.recipe_tab_hovered(layout) {
+                return Some((sent, stack));
+            }
+            let (_, _, sent, stack) = self.recipe_slot_hovered(layout)?;
+            return Some((sent, stack));
+        }
+        let (index, stack) = self.browser_hovered(layout)?;
+        let (_, _, items) = self.mods.mods.browser_items()?;
+        Some((items.get(index)?.clone(), stack))
+    }
+    /// The panel's item under the pointer: its index and stack.
+    fn browser_hovered(&self, layout: &Layout) -> Option<(usize, ItemStack)> {
+        if self.mods.browser.recipes.is_some() {
+            return None;
+        }
+        let first = self.mods.browser.page * layout.per_page();
+        (0..layout.per_page()).find_map(|n| {
+            let (x, y) = layout.slot(n);
+            if !inside(self.cursor, [x, y, SLOT, SLOT]) {
+                return None;
+            }
+            let stack = self.mods.browser.stacks.get(first + n)?.clone()?;
+            Some((first + n, stack))
+        })
+    }
+    fn browser_search(&mut self, layout: &Layout) -> &mut EditBox {
+        let search = self.mods.browser.search.get_or_insert_with(|| {
+            let mut edit = EditBox::new(0.0, 0.0, 0.0, 0.0);
+            edit.max_length = 50;
+            edit.focused = false;
+            edit
+        });
+        [search.x, search.y, search.width, search.height] = layout.search;
+        search
+    }
+
+    /// The items' page arrows and grid.
+    fn draw_browser_items(&mut self, batch: &mut HudBatch, layout: &Layout) {
+        let pages = self.browser_pages(layout);
+        self.mods.browser.page = self.mods.browser.page.min(pages - 1);
+        let page = self.mods.browser.page;
+        let cursor = self.cursor;
+        if pages > 1 {
+            let labels = [
+                self.translate("gui.recipebook.previous_page", "Previous Page"),
+                self.translate("gui.recipebook.next_page", "Next Page"),
+            ];
+            let shown = [page > 0, page + 1 < pages];
+            let atlas = &self.gui.atlas;
+            for (((x, y), name), (label, shown)) in layout
+                .arrows()
+                .into_iter()
+                .zip(["page_backward", "page_forward"])
+                .zip(labels.iter().zip(shown))
+            {
+                if !shown {
+                    continue;
+                }
+                let hover = inside(cursor, [x, y, 12.0, 17.0]);
+                let suffix = if hover { "_highlighted" } else { "" };
+                batch.sprite(
+                    atlas,
+                    &format!("gui/sprites/recipe_book/{name}{suffix}"),
+                    x,
+                    y,
+                );
+                horizon_client::widgets::record(label, [x, y, 12.0, 17.0], true);
+            }
+            let text = format!("{}/{pages}", page + 1);
+            let w = HudBatch::text_width(atlas, &text);
+            let x = (layout.grid.0 + (layout.width() - w) / 2.0).floor();
+            batch.text(atlas, &text, x, layout.arrows_y + 5.0, u32::MAX, true);
+        }
+        let first = page * layout.per_page();
+        for n in 0..layout.per_page() {
+            let Some(stack) = self.mods.browser.stacks.get(first + n) else {
+                break;
+            };
+            let Some(stack) = stack.clone() else {
+                continue;
+            };
+            let (x, y) = layout.slot(n);
+            self.draw_item(batch, &stack, x + 1.0, y + 1.0);
+            let rect = [x + 1.0, y + 1.0, 16.0, 16.0];
+            if inside(cursor, [x, y, SLOT, SLOT]) {
+                batch.fill(
+                    &self.gui.atlas,
+                    x + 1.0,
+                    y + 1.0,
+                    16.0,
+                    16.0,
+                    rgba(255, 255, 255, 128),
+                );
+            }
+            let name = self.pack.names.display_item(&stack.item);
+            horizon_client::widgets::record_as(
+                &name,
+                rect,
+                true,
+                horizon_client::widgets::Kind::Button,
+            );
+        }
+    }
+    /// Draws the panel over the open container screen, then the carried
+    /// stack or the tooltip again so they stay on top of it.
+    pub(super) fn draw_mod_browser(&mut self, batch: &mut HudBatch) {
+        if self.browser_sync().is_none() {
+            return;
+        }
+        let Some(layout) = self.browser_layout(batch) else {
+            return;
+        };
+        let cursor = self.cursor;
+        if self.mods.browser.recipes.is_some() {
+            self.draw_browser_recipes(batch, &layout);
+        } else {
+            self.draw_browser_items(batch, &layout);
+        }
+        let hint = self.translate("gui.recipebook.search_hint", "Search...");
+        let search = self.browser_search(&layout);
+        // The hint shows in an empty box without focus, as the recipe book's.
+        search.suggestion = (search.value.is_empty() && !search.focused).then_some(hint);
+        let mut search = search.clone();
+        search.draw(batch, &self.gui.atlas, None);
+        self.mods.browser.search = Some(search);
+        if self.carried.is_some() {
+            self.draw_carried(batch);
+        } else if let Some(stack) = self.browser_pointed_stack(&layout) {
+            let lines = self.stack_tooltip(&stack.1);
+            self.draw_tooltip_lines(batch, &lines, cursor.0, cursor.1);
+        } else {
+            self.draw_slot_tooltip(batch);
+        }
+    }
+
+    /// A mouse press on a container screen: true when the panel took it
+    /// (its search box, page arrows, items or empty space; a click there
+    /// never throws the carried stack).
+    pub(super) fn mod_browser_press(&mut self, right: bool) -> bool {
+        let Some(owner) = self.browser_sync() else {
+            return false;
+        };
+        let Some(batch) = self.browser_batch() else {
+            return false;
+        };
+        let Some(layout) = self.browser_layout(&batch) else {
+            return false;
+        };
+        let cursor = self.cursor;
+        let shift = self.has_shift_down();
+        let atlas = &self.gui.atlas;
+        let search = self.mods.browser.search.get_or_insert_with(|| {
+            let mut edit = EditBox::new(0.0, 0.0, 0.0, 0.0);
+            edit.max_length = 50;
+            edit
+        });
+        [search.x, search.y, search.width, search.height] = layout.search;
+        if inside(cursor, layout.search) {
+            search.focused = true;
+            search.click(atlas, cursor.0, shift, false);
+            search.reset_blink();
+            return true;
+        }
+        search.focused = false;
+        if self.mods.browser.recipes.is_some() {
+            return self.browser_recipes_press(&layout, owner, right)
+                || inside(cursor, layout.area);
+        }
+        let pages = self.browser_pages(&layout);
+        let page = self.mods.browser.page;
+        let [back, forward] = layout.arrows();
+        let step = if pages > 1 && page > 0 && inside(cursor, [back.0, back.1, 12.0, 17.0]) {
+            Some(page - 1)
+        } else if pages > 1
+            && page + 1 < pages
+            && inside(cursor, [forward.0, forward.1, 12.0, 17.0])
+        {
+            Some(page + 1)
+        } else {
+            None
+        };
+        if let Some(to) = step {
+            self.mods.browser.page = to;
+            self.audio
+                .play("minecraft:ui.button.click", None, 0.25, 1.0);
+            return true;
+        }
+        if let Some((index, _)) = self.browser_hovered(&layout) {
+            let event = BrowserEvent::Clicked(BrowserClick {
+                index: index as u32,
+                right,
+            });
+            self.mods.mods.browser_event(owner, event);
+            return true;
+        }
+        inside(cursor, layout.area)
+    }
+
+    /// Whether keys go to the panel's search box.
+    pub(super) fn mod_browser_typing(&self) -> bool {
+        self.screen == Screen::Inventory
+            && self.mods.browser.of.is_some()
+            && self.mods.browser.search.as_ref().is_some_and(|s| s.focused)
+    }
+    /// A key press while the search box has focus.
+    pub(super) fn mod_browser_key(&mut self, event: &winit::event::KeyEvent) {
+        use winit::keyboard::PhysicalKey;
+        let shortcut = self.edit_shortcut(event);
+        let ctrl = self.has_control_down();
+        let shift = self.has_shift_down();
+        let Some(search) = self.mods.browser.search.as_mut() else {
+            return;
+        };
+        if let Some(shortcut) = shortcut {
+            search.shortcut(shortcut, &mut self.clipboard);
+        } else {
+            let handled = match event.physical_key {
+                PhysicalKey::Code(code) => search.key(code, ctrl, shift),
+                _ => false,
+            };
+            if !handled
+                && !ctrl
+                && let Some(text) = &event.text
+            {
+                let text: String = text.chars().filter(|c| !c.is_control()).collect();
+                search.insert_text(&text);
+            }
+        }
+        search.reset_blink();
+        self.browser_searched();
+    }
+    /// Text typed (or one backspace) into the search box (`horizon-ctl type`).
+    pub(super) fn mod_browser_text(&mut self, text: Option<&str>, backspace: bool) {
+        let Some(search) = self.mods.browser.search.as_mut() else {
+            return;
+        };
+        if backspace {
+            search.delete_chars(-1);
+        } else if let Some(text) = text {
+            search.insert_text(text);
+        }
+        self.browser_searched();
+    }
+    /// The mod hears the search text when it changed.
+    fn browser_searched(&mut self) {
+        let (Some((owner, _)), Some(search)) = (self.mods.browser.of, &self.mods.browser.search)
+        else {
+            return;
+        };
+        if search.value != self.mods.browser.sent {
+            let value = search.value.clone();
+            self.mods.browser.sent.clone_from(&value);
+            self.mods.browser.page = 0;
+            self.mods
+                .mods
+                .browser_event(owner, BrowserEvent::Search(value));
+        }
+    }
+    /// The container screen closed: the search box lets go of the keys.
+    pub(super) fn mod_browser_closed(&mut self) {
+        if let Some(search) = self.mods.browser.search.as_mut() {
+            search.focused = false;
+        }
+    }
+    /// The item under the pointer on a container screen, for the mods' keys
+    /// (`browser`'s `key` event): the panel's, else a slot's.
+    pub(super) fn mod_browser_pointed(&mut self) -> Option<BrowserStack> {
+        let batch = self.browser_batch()?;
+        let stack = match self
+            .browser_sync()
+            .and_then(|_| self.browser_layout(&batch))
+        {
+            // The panel's stacks as the mod sent them.
+            Some(layout) if inside(self.cursor, layout.area) => {
+                return Some(self.browser_pointed_stack(&layout)?.0);
+            }
+            _ => {
+                let slot = self.slot_at(&batch, self.cursor.0, self.cursor.1)?;
+                self.slot_view(slot)?
+            }
+        };
+        Some(BrowserStack {
+            item: stack.item.to_string(),
+            count: stack.count,
+            components: super::mod_recipes::components(&stack),
+        })
+    }
+}
+
+/// A mod's item as a stack: an item the game has, its components read as
+/// `/give` reads them (ones it can't read are left out).
+#[cfg(feature = "mods")]
+pub(super) fn browser_stack(
+    items: &horizon_client::items::Items,
+    s: &BrowserStack,
+) -> Option<ItemStack> {
+    items.get(&s.item)?;
+    let (damage, extra) = if s.components.is_empty() {
+        (0, None)
+    } else {
+        horizon_client::item_data::command_components(&s.components).map_or((0, None), |tag| {
+            horizon_client::item_data::decode_components(Some(&tag))
+        })
+    };
+    Some(ItemStack {
+        item: s.item.as_str().into(),
+        count: s.count.clamp(1, 99),
+        damage,
+        extra,
+    })
+}
diff --git a/crates/horizon-client/src/game/mod_browser_recipes.rs b/crates/horizon-client/src/game/mod_browser_recipes.rs
new file mode 100644
index 000000000..557ae9029
--- /dev/null
+++ b/crates/horizon-client/src/game/mod_browser_recipes.rs
@@ -0,0 +1,523 @@
+//! `browser.set-recipes` (docs/mods.md): a mod's recipes shown in its item
+//! panel's place, laid out by the game with its own slots, arrows and
+//! buttons, paged to the panel's height, under a title and a back button.
+//! The mod hears clicks on their slots, their action buttons, the back
+//! button and page turns.
+use super::{
+    Game,
+    mod_browser::{Layout, browser_stack, inside},
+};
+use horizon_client::{
+    hud::{HudBatch, rgba},
+    items::ItemStack,
+};
+use horizon_mods::{BrowserEvent, BrowserLayout, BrowserSlotClick, BrowserStack, RecipePage};
+use std::time::Instant;
+
+const SLOT: f32 = 18.0;
+/// The title row's height, and the gap under each recipe.
+const TITLE: f32 = 18.0;
+/// A tab's step: an 18 px slot and a gap.
+const TAB: f32 = 20.0;
+const GAP: f32 = 6.0;
+
+/// One recipe as the game draws it.
+pub(super) struct Shown {
+    layout: BrowserLayout,
+    width: usize,
+    height: usize,
+    /// Each slot's stacks (the result last), as the mod sent them and as
+    /// stacks; a stack the game doesn't have is left out of the cycle.
+    slots: Vec<Vec<(BrowserStack, ItemStack)>>,
+    note: String,
+    action: Option<bool>,
+}
+
+/// The recipes a panel shows, and its page.
+pub(super) struct Pages {
+    title: String,
+    /// The tabs' icons and the selected one.
+    tabs: Vec<(BrowserStack, Option<ItemStack>)>,
+    tab: usize,
+    recipes: Vec<Shown>,
+    page: usize,
+    since: Instant,
+}
+
+impl Pages {
+    pub(super) fn new(
+        items: &horizon_client::items::Items,
+        shown: &RecipePage,
+        old: Option<Pages>,
+    ) -> Self {
+        let (title, list, tab) = (&shown.title, &shown.recipes, shown.tab as usize);
+        let kept = old.filter(|o| o.title == *title && o.tab == tab);
+        let cycle = |stacks: &[BrowserStack]| -> Vec<(BrowserStack, ItemStack)> {
+            stacks
+                .iter()
+                .filter_map(|s| Some((s.clone(), browser_stack(items, s)?)))
+                .collect()
+        };
+        let recipes = list
+            .iter()
+            .map(|r| {
+                let mut slots: Vec<_> = r.slots.iter().map(|s| cycle(s)).collect();
+                slots.push(cycle(&r.results));
+                Shown {
+                    layout: r.layout,
+                    width: r.width as usize,
+                    height: r.height as usize,
+                    slots,
+                    note: r.note.clone(),
+                    action: r.action,
+                }
+            })
+            .collect();
+        Self {
+            title: title.clone(),
+            tabs: shown
+                .tabs
+                .iter()
+                .map(|t| (t.clone(), browser_stack(items, t)))
+                .collect(),
+            tab,
+            recipes,
+            page: kept.as_ref().map_or(0, |o| o.page),
+            since: kept.map_or_else(Instant::now, |o| o.since),
+        }
+    }
+}
+
+impl Shown {
+    /// The inputs' block: its size and each input slot's place in it.
+    fn inputs(&self) -> ((f32, f32), Vec<(f32, f32)>) {
+        let row = |n: usize| (0..n).map(|i| (i as f32 * SLOT, 0.0)).collect();
+        match self.layout {
+            BrowserLayout::Grid => {
+                let (w, h) = (self.width.max(1), self.height.max(1));
+                let at = (0..w * h)
+                    .map(|i| ((i % w) as f32 * SLOT, (i / w) as f32 * SLOT))
+                    .collect();
+                ((w as f32 * SLOT, h as f32 * SLOT), at)
+            }
+            // The input over the flame.
+            BrowserLayout::Cooking => ((SLOT, 2.0 * SLOT), vec![(0.0, 0.0)]),
+            BrowserLayout::Single => ((SLOT, SLOT), row(1)),
+            BrowserLayout::Smithing => ((3.0 * SLOT, SLOT), row(3)),
+            BrowserLayout::Brewing => ((2.0 * SLOT, SLOT), row(2)),
+        }
+    }
+    /// The height of its slots, arrow and button, `room` wide.
+    fn block(&self, room: f32) -> f32 {
+        let h = self.inputs().0.1;
+        let (_, _, action) = self.places(room);
+        match self.action {
+            Some(_) => h.max(action.1 + 12.0),
+            None => h,
+        }
+    }
+    fn height(&self, room: f32) -> f32 {
+        let note = if self.note.is_empty() { 0.0 } else { 11.0 };
+        self.block(room) + note + GAP
+    }
+    /// Every slot's place from the recipe's corner (the result last), the
+    /// arrow's and the action button's: beside the result, or under it
+    /// when the panel is `room` wide and that doesn't fit.
+    fn places(&self, room: f32) -> (Vec<(f32, f32)>, (f32, f32), (f32, f32)) {
+        let ((w, h), mut at) = self.inputs();
+        // The mod's slots beyond the layout's are not shown.
+        at.truncate(self.slots.len() - 1);
+        let arrow = (w + 4.0, ((h - 16.0) / 2.0).floor());
+        let result = (w + 32.0, ((h - SLOT) / 2.0).floor());
+        let action = if result.0 + SLOT + 16.0 <= room {
+            (result.0 + SLOT + 4.0, ((h - 12.0) / 2.0).floor())
+        } else {
+            (result.0 + 3.0, result.1 + SLOT + 2.0)
+        };
+        while at.len() < self.slots.len() - 1 {
+            at.push((f32::NAN, f32::NAN));
+        }
+        at.push(result);
+        (at, arrow, action)
+    }
+}
+
+/// The tabs' places, in rows under the title row.
+fn tab_places(pages: &Pages, layout: &Layout) -> Vec<(f32, f32)> {
+    let per_row = ((layout.width() / TAB).floor() as usize).max(1);
+    (0..pages.tabs.len())
+        .map(|i| {
+            (
+                layout.grid.0 + (i % per_row) as f32 * TAB,
+                layout.grid.1 + TITLE + 3.0 + (i / per_row) as f32 * TAB,
+            )
+        })
+        .collect()
+}
+/// Where the recipes start: under the title row and the tabs.
+fn recipes_top(pages: &Pages, layout: &Layout) -> f32 {
+    let tabs = tab_places(pages, layout);
+    tabs.last()
+        .map_or(layout.grid.1 + TITLE, |&(_, y)| y + TAB + 3.0)
+}
+
+impl Game<'_> {
+    /// The first recipe of each page, filling the panel from the tabs to
+    /// the search box.
+    fn recipe_pages(pages: &Pages, layout: &Layout) -> Vec<usize> {
+        let room = layout.search[1] - 4.0 - recipes_top(pages, layout);
+        let mut starts = vec![0];
+        let mut used = 0.0;
+        for (i, r) in pages.recipes.iter().enumerate() {
+            let h = r.height(layout.width());
+            if used > 0.0 && used + h > room {
+                starts.push(i);
+                used = 0.0;
+            }
+            used += h;
+        }
+        starts
+    }
+    /// The recipes on the open page, each with its corner.
+    fn recipes_shown(&self, layout: &Layout) -> Vec<(usize, (f32, f32))> {
+        let Some(pages) = &self.mods.browser.recipes else {
+            return Vec::new();
+        };
+        let starts = Self::recipe_pages(pages, layout);
+        let page = pages.page.min(starts.len() - 1);
+        let end = starts.get(page + 1).copied().unwrap_or(pages.recipes.len());
+        let mut y = recipes_top(pages, layout);
+        (starts[page]..end)
+            .map(|i| {
+                let at = (layout.grid.0, y);
+                y += pages.recipes[i].height(layout.width());
+                (i, at)
+            })
+            .collect()
+    }
+    fn back_button(&self, layout: &Layout) -> ([f32; 4], String) {
+        let label = self.translate("gui.back", "Back");
+        let w = HudBatch::text_width(&self.gui.atlas, &label) + 8.0;
+        ([layout.grid.0, layout.grid.1, w, 14.0], label)
+    }
+    /// What a slot of a shown recipe holds now: its stacks cycle once a second.
+    fn recipe_slot_now(&self, recipe: usize, slot: usize) -> Option<&(BrowserStack, ItemStack)> {
+        let pages = self.mods.browser.recipes.as_ref()?;
+        let stacks = pages.recipes.get(recipe)?.slots.get(slot)?;
+        let n = pages.since.elapsed().as_secs() as usize;
+        stacks.get(n % stacks.len().max(1))
+    }
+    /// The tab under the pointer: its index and icon.
+    pub(super) fn recipe_tab_hovered(
+        &self,
+        layout: &Layout,
+    ) -> Option<(usize, BrowserStack, ItemStack)> {
+        let pages = self.mods.browser.recipes.as_ref()?;
+        let places = tab_places(pages, layout);
+        places.iter().enumerate().find_map(|(i, &(x, y))| {
+            if !inside(self.cursor, [x, y, SLOT, SLOT]) {
+                return None;
+            }
+            let (sent, stack) = pages.tabs.get(i)?;
+            Some((i, sent.clone(), stack.clone()?))
+        })
+    }
+    /// The recipe slot under the pointer: recipe, slot, and its stack now.
+    pub(super) fn recipe_slot_hovered(
+        &self,
+        layout: &Layout,
+    ) -> Option<(usize, usize, BrowserStack, ItemStack)> {
+        let pages = self.mods.browser.recipes.as_ref()?;
+        self.recipes_shown(layout)
+            .into_iter()
+            .find_map(|(i, (x, y))| {
+                let (at, _, _) = pages.recipes[i].places(layout.width());
+                at.iter().enumerate().find_map(|(k, &(sx, sy))| {
+                    if !inside(self.cursor, [x + sx, y + sy, SLOT, SLOT]) {
+                        return None;
+                    }
+                    let (mod_stack, stack) = self.recipe_slot_now(i, k)?.clone();
+                    Some((i, k, mod_stack, stack))
+                })
+            })
+    }
+
+    /// Draws the title row, the page's recipes and the page arrows.
+    pub(super) fn draw_browser_recipes(&mut self, batch: &mut HudBatch, layout: &Layout) {
+        let Some(pages) = &self.mods.browser.recipes else {
+            return;
+        };
+        let cursor = self.cursor;
+        let starts = Self::recipe_pages(pages, layout);
+        let page = pages.page.min(starts.len() - 1);
+        let (title, pages_n) = (pages.title.clone(), starts.len());
+        let (back, label) = self.back_button(layout);
+        let atlas = &self.gui.atlas;
+        let hover = inside(cursor, back);
+        let sprite = if hover {
+            "gui/sprites/widget/button_highlighted"
+        } else {
+            "gui/sprites/widget/button"
+        };
+        horizon_client::ui::nine_slice(
+            batch,
+            atlas,
+            sprite,
+            back[0],
+            back[1],
+            back[2],
+            back[3],
+            u32::MAX,
+        );
+        batch.text(atlas, &label, back[0] + 4.0, back[1] + 3.0, u32::MAX, true);
+        horizon_client::widgets::record(&label, back, true);
+        let room = layout.width() - back[2] - 4.0;
+        // Cut to the panel with vanilla's ellipsis (CommonComponents.ELLIPSIS).
+        let shown = if atlas.font.fit(&title, room) >= title.chars().count() {
+            title
+        } else {
+            let fit = atlas.font.fit(&title, room - atlas.font.width("..."));
+            let kept: String = title.chars().take(fit).collect();
+            format!("{}...", kept.trim_end())
+        };
+        batch.text(
+            atlas,
+            &shown,
+            back[0] + back[2] + 4.0,
+            back[1] + 3.0,
+            u32::MAX,
+            true,
+        );
+        self.draw_recipe_tabs(batch, layout);
+        if pages_n > 1 {
+            let labels = [
+                self.translate("gui.recipebook.previous_page", "Previous Page"),
+                self.translate("gui.recipebook.next_page", "Next Page"),
+            ];
+            let visible = [page > 0, page + 1 < pages_n];
+            let atlas = &self.gui.atlas;
+            for (((x, y), name), (label, visible)) in layout
+                .arrows()
+                .into_iter()
+                .zip(["page_backward", "page_forward"])
+                .zip(labels.iter().zip(visible))
+            {
+                if !visible {
+                    continue;
+                }
+                let suffix = if inside(cursor, [x, y, 12.0, 17.0]) {
+                    "_highlighted"
+                } else {
+                    ""
+                };
+                batch.sprite(
+                    atlas,
+                    &format!("gui/sprites/recipe_book/{name}{suffix}"),
+                    x,
+                    y,
+                );
+                horizon_client::widgets::record(label, [x, y, 12.0, 17.0], true);
+            }
+            let text = format!("{}/{pages_n}", page + 1);
+            let w = HudBatch::text_width(atlas, &text);
+            let x = (layout.grid.0 + (layout.width() - w) / 2.0).floor();
+            batch.text(atlas, &text, x, layout.arrows_y + 5.0, u32::MAX, true);
+        }
+        for (i, (x, y)) in self.recipes_shown(layout) {
+            let Some(r) = self.mods.browser.recipes.as_ref().map(|p| &p.recipes[i]) else {
+                break;
+            };
+            let (at, arrow, action) = r.places(layout.width());
+            let h = r.block(layout.width());
+            let (cooking, note, button) =
+                (r.layout == BrowserLayout::Cooking, r.note.clone(), r.action);
+            let atlas = &self.gui.atlas;
+            for &(sx, sy) in at.iter().filter(|p| p.0.is_finite()) {
+                batch.sprite(atlas, "gui/sprites/container/slot", x + sx, y + sy);
+            }
+            if cooking {
+                batch.sprite(
+                    atlas,
+                    "gui/sprites/container/furnace/lit_progress",
+                    x + 2.0,
+                    y + SLOT + 2.0,
+                );
+            }
+            batch.sprite(
+                atlas,
+                "gui/sprites/container/furnace/burn_progress",
+                x + arrow.0,
+                y + arrow.1,
+            );
+            if let Some(enabled) = button {
+                let rect = [x + action.0, y + action.1, 12.0, 12.0];
+                let sprite = match (enabled, inside(cursor, rect)) {
+                    (false, _) => "gui/sprites/widget/button_disabled",
+                    (true, true) => "gui/sprites/widget/button_highlighted",
+                    (true, false) => "gui/sprites/widget/button",
+                };
+                horizon_client::ui::nine_slice(
+                    batch,
+                    atlas,
+                    sprite,
+                    rect[0],
+                    rect[1],
+                    12.0,
+                    12.0,
+                    u32::MAX,
+                );
+                let color = if enabled {
+                    u32::MAX
+                } else {
+                    rgba(160, 160, 160, 255)
+                };
+                batch.text(atlas, "+", rect[0] + 3.0, rect[1] + 2.0, color, true);
+                horizon_client::widgets::record(&format!("+ {i}"), rect, enabled);
+            }
+            if !note.is_empty() {
+                batch.text(atlas, &note, x, y + h + 2.0, rgba(224, 224, 224, 255), true);
+            }
+            for (k, &(sx, sy)) in at.iter().enumerate().filter(|(_, p)| p.0.is_finite()) {
+                let Some((_, stack)) = self.recipe_slot_now(i, k).cloned() else {
+                    continue;
+                };
+                self.draw_item(batch, &stack, x + sx + 1.0, y + sy + 1.0);
+                if inside(cursor, [x + sx, y + sy, SLOT, SLOT]) {
+                    batch.fill(
+                        &self.gui.atlas,
+                        x + sx + 1.0,
+                        y + sy + 1.0,
+                        16.0,
+                        16.0,
+                        rgba(255, 255, 255, 128),
+                    );
+                }
+                let name = self.pack.names.display_item(&stack.item);
+                horizon_client::widgets::record_as(
+                    &format!("{name} {i}:{k}"),
+                    [x + sx + 1.0, y + sy + 1.0, 16.0, 16.0],
+                    true,
+                    horizon_client::widgets::Kind::Button,
+                );
+            }
+        }
+    }
+
+    /// The tabs, on slots; the selected one framed.
+    fn draw_recipe_tabs(&mut self, batch: &mut HudBatch, layout: &Layout) {
+        let Some(pages) = &self.mods.browser.recipes else {
+            return;
+        };
+        let places = tab_places(pages, layout);
+        let tabs: Vec<Option<ItemStack>> = pages.tabs.iter().map(|t| t.1.clone()).collect();
+        let selected = pages.tab;
+        for (i, (&(x, y), stack)) in places.iter().zip(tabs).enumerate() {
+            let atlas = &self.gui.atlas;
+            batch.sprite(atlas, "gui/sprites/container/slot", x, y);
+            let Some(stack) = stack else {
+                continue;
+            };
+            self.draw_item(batch, &stack, x + 1.0, y + 1.0);
+            // The selected tab: a white frame around its slot.
+            if i == selected {
+                let white = rgba(255, 255, 255, 255);
+                let atlas = &self.gui.atlas;
+                batch.fill(atlas, x - 1.0, y - 1.0, SLOT + 2.0, 1.0, white);
+                batch.fill(atlas, x - 1.0, y + SLOT, SLOT + 2.0, 1.0, white);
+                batch.fill(atlas, x - 1.0, y, 1.0, SLOT, white);
+                batch.fill(atlas, x + SLOT, y, 1.0, SLOT, white);
+            }
+            if inside(self.cursor, [x, y, SLOT, SLOT]) {
+                batch.fill(
+                    &self.gui.atlas,
+                    x + 1.0,
+                    y + 1.0,
+                    16.0,
+                    16.0,
+                    rgba(255, 255, 255, 128),
+                );
+            }
+            let name = self.pack.names.display_item(&stack.item);
+            horizon_client::widgets::record_as(
+                &format!("{name} tab"),
+                [x + 1.0, y + 1.0, 16.0, 16.0],
+                true,
+                horizon_client::widgets::Kind::Tab(i == selected),
+            );
+        }
+    }
+
+    /// A press on the recipes: true when it hit one of their parts.
+    pub(super) fn browser_recipes_press(
+        &mut self,
+        layout: &Layout,
+        owner: usize,
+        right: bool,
+    ) -> bool {
+        let Some(pages) = &self.mods.browser.recipes else {
+            return false;
+        };
+        let cursor = self.cursor;
+        let starts = Self::recipe_pages(pages, layout);
+        let page = pages.page.min(starts.len() - 1);
+        let [back_arrow, forward] = layout.arrows();
+        let turn = if page > 0 && inside(cursor, [back_arrow.0, back_arrow.1, 12.0, 17.0]) {
+            Some(page - 1)
+        } else if page + 1 < starts.len() && inside(cursor, [forward.0, forward.1, 12.0, 17.0]) {
+            Some(page + 1)
+        } else {
+            None
+        };
+        if let Some(to) = turn {
+            if let Some(p) = self.mods.browser.recipes.as_mut() {
+                p.page = to;
+            }
+            self.audio
+                .play("minecraft:ui.button.click", None, 0.25, 1.0);
+            self.mods
+                .mods
+                .browser_event(owner, BrowserEvent::Page(starts[to] as u32));
+            return true;
+        }
+        if let Some((tab, _, _)) = self.recipe_tab_hovered(layout) {
+            self.audio
+                .play("minecraft:ui.button.click", None, 0.25, 1.0);
+            self.mods
+                .mods
+                .browser_event(owner, BrowserEvent::Tab(tab as u32));
+            return true;
+        }
+        if inside(cursor, self.back_button(layout).0) {
+            self.audio
+                .play("minecraft:ui.button.click", None, 0.25, 1.0);
+            self.mods.mods.browser_event(owner, BrowserEvent::Back);
+            return true;
+        }
+        if let Some((recipe, slot, stack, _)) = self.recipe_slot_hovered(layout) {
+            let event = BrowserEvent::SlotClicked(BrowserSlotClick {
+                recipe: recipe as u32,
+                slot: slot as u32,
+                stack,
+                right,
+            });
+            self.mods.mods.browser_event(owner, event);
+            return true;
+        }
+        let action = self.recipes_shown(layout).into_iter().find(|&(i, (x, y))| {
+            let r = &pages.recipes[i];
+            let (_, _, (ax, ay)) = r.places(layout.width());
+            r.action.is_some() && inside(cursor, [x + ax, y + ay, 12.0, 12.0])
+        });
+        if let Some((i, _)) = action {
+            if pages.recipes[i].action == Some(true) {
+                self.audio
+                    .play("minecraft:ui.button.click", None, 0.25, 1.0);
+                self.mods
+                    .mods
+                    .browser_event(owner, BrowserEvent::Action(i as u32));
+            }
+            return true;
+        }
+        false
+    }
+}
diff --git a/crates/horizon-client/src/game/mod_input.rs b/crates/horizon-client/src/game/mod_input.rs
index 10faf6a81..3769b03c9 100644
--- a/crates/horizon-client/src/game/mod_input.rs
+++ b/crates/horizon-client/src/game/mod_input.rs
@@ -31,6 +31,9 @@ impl Game<'_> {
     pub(super) fn mod_minimap(&self) -> Option<ModMinimap> {
         None
     }
+    pub(super) fn mod_far_terrain(&self) -> Option<ModFarTerrain> {
+        None
+    }
 }
 
 /// A mod's zoom (`render.set-zoom`), clamped by the runtime.
@@ -51,6 +54,13 @@ pub(super) struct ModMinimap {
     pub(super) round: bool,
 }
 
+/// A mod's far terrain (`render.set-far-terrain`), clamped by the runtime.
+#[derive(Clone, Copy)]
+pub(super) struct ModFarTerrain {
+    pub(super) distance: u32,
+    pub(super) reduced: bool,
+}
+
 #[cfg(feature = "mods")]
 impl Game<'_> {
     /// The main hand's stack as `input` shows it; none when it is empty.
@@ -111,6 +121,18 @@ impl Game<'_> {
         if repeat || !self.mods.mods.has_keys() {
             return;
         }
+        // Over an item on a container screen, the mods' keys are `browser`
+        // events (a recipe viewer's R and U).
+        if pressed
+            && self.screen == Screen::Inventory
+            && self.title.is_none()
+            && !self.mod_browser_typing()
+            && let Some(name) = horizon_client::keybinds::key_name(key)
+            && let Some(stack) = self.mod_browser_pointed()
+        {
+            self.mods.mods.browser_key(name, &stack);
+            return;
+        }
         if pressed && (self.screen != Screen::Playing || self.title.is_some()) {
             return;
         }
@@ -178,4 +200,12 @@ impl Game<'_> {
             round: m.round,
         })
     }
+    /// The far terrain the first mod drawing one asks for.
+    pub(super) fn mod_far_terrain(&self) -> Option<ModFarTerrain> {
+        let f = self.mods.mods.far_terrain()?;
+        Some(ModFarTerrain {
+            distance: f.distance,
+            reduced: f.reduced,
+        })
+    }
 }
diff --git a/crates/horizon-client/src/game/mod_recipes.rs b/crates/horizon-client/src/game/mod_recipes.rs
new file mode 100644
index 000000000..b97944e39
--- /dev/null
+++ b/crates/horizon-client/src/game/mod_recipes.rs
@@ -0,0 +1,274 @@
+//! Capability `recipes` (docs/mods.md): every item and recipe the game
+//! knows, made once for the mods that read them, and the recipe book's
+//! known displays. The recipes are the window's own data: the world's in
+//! single player, vanilla's on a server (a client is sent no others), while
+//! the known displays follow the server's book as the recipe book does.
+use super::Game;
+use horizon_client::{
+    crafting::Ingredient,
+    items::ItemStack,
+    recipe_book::{Category, Display},
+    stations::Smithing,
+};
+use horizon_mods::{Recipe, RecipeItem, RecipeKind, RecipeStack, Recipes};
+use std::{collections::HashMap, sync::Arc};
+
+/// Item id -> its index in [`Recipes::items`].
+struct Index(HashMap<Arc<str>, u32>);
+impl Index {
+    fn stack(&self, item: &str, count: u32, components: String) -> Option<RecipeStack> {
+        Some(RecipeStack {
+            item: *self.0.get(item)?,
+            count,
+            components,
+        })
+    }
+    fn of(&self, s: &ItemStack) -> Option<RecipeStack> {
+        self.stack(&s.item, s.count, components(s))
+    }
+    fn any(&self, i: &Ingredient) -> Vec<RecipeStack> {
+        i.1.iter()
+            .filter_map(|id| self.stack(id, 1, String::new()))
+            .collect()
+    }
+}
+
+/// A stack's components beyond its item's, as vanilla's item syntax writes
+/// them (`[minecraft:potion_contents={potion:"minecraft:swiftness"}]`), or "".
+pub(super) fn components(s: &ItemStack) -> String {
+    use horizon_world::nbt::Tag;
+    let Some(Tag::Compound(entries)) = horizon_client::item_data::encode_components(s) else {
+        return String::new();
+    };
+    let parts: Vec<String> = entries
+        .iter()
+        .map(|(k, v)| {
+            format!(
+                "{}={}",
+                k.to_string_lossy(),
+                horizon_client::snbt::to_snbt(v)
+            )
+        })
+        .collect();
+    format!("[{}]", parts.join(","))
+}
+
+fn recipe(id: String, kind: RecipeKind) -> Recipe {
+    Recipe {
+        id,
+        kind,
+        category: String::new(),
+        group: String::new(),
+        width: 0,
+        height: 0,
+        slots: Vec::new(),
+        results: Vec::new(),
+        cooking_time: 0,
+        experience: 0.0,
+        book_id: -1,
+    }
+}
+
+impl Game<'_> {
+    /// `recipes.give`: a creative player takes the stack as from the
+    /// creative inventory; a server hears it as `SetCreativeModeSlot`
+    /// through the inventory's sync, and refuses it unless creative.
+    pub(super) fn mod_give(&mut self, item: &str, count: u32, components: &str) {
+        let Some(max) = self.res.items().get(item).map(|i| i.max_stack) else {
+            return;
+        };
+        if !self.creative {
+            return;
+        }
+        let (damage, extra) = horizon_client::item_data::command_components(components)
+            .map_or((0, None), |tag| {
+                horizon_client::item_data::decode_components(Some(&tag))
+            });
+        let _ = self.give(ItemStack {
+            item: item.into(),
+            // One stack at most, as the creative inventory hands out.
+            count: count.min(max),
+            damage,
+            extra,
+        });
+    }
+    /// Capability `recipes`'s tables and known displays for this tick's
+    /// snapshot; nothing while no running mod reads them.
+    pub(super) fn mod_recipes(&mut self) -> (Option<Arc<Recipes>>, Arc<[i32]>) {
+        if !self.mods.mods.wants_recipes() {
+            return (None, Arc::from([]));
+        }
+        if self.mods.recipes.is_none() {
+            self.mods.recipes = Some(Arc::new(self.make_mod_recipes()));
+        }
+        let (version, known) = self.recipe_book_displays();
+        if self.mods.known_recipes.0 != Some(version) {
+            self.mods.known_recipes = (Some(version), known.into());
+        }
+        (self.mods.recipes.clone(), self.mods.known_recipes.1.clone())
+    }
+
+    fn make_mod_recipes(&mut self) -> Recipes {
+        let names = &self.pack.names;
+        let items = self.res.items();
+        let mut tags: HashMap<&str, Vec<String>> = HashMap::new();
+        for (tag, members) in &items.item_tags {
+            for m in members {
+                tags.entry(m).or_default().push(tag.clone());
+            }
+        }
+        let table: Vec<RecipeItem> = items
+            .registry_order
+            .iter()
+            .map(|id| RecipeItem {
+                id: id.to_string(),
+                name: names.display_item(id),
+                tags: tags.remove(&**id).map_or_else(Vec::new, |mut t| {
+                    t.sort();
+                    t
+                }),
+            })
+            .collect();
+        let index = Index(
+            items
+                .registry_order
+                .iter()
+                .enumerate()
+                .map(|(i, id)| (id.clone(), i as u32))
+                .collect(),
+        );
+        let mut out = Vec::new();
+        let cooking: HashMap<String, (u32, f32)> = self
+            .res
+            .recipes()
+            .cooking
+            .iter()
+            .map(|c| (format!("minecraft:{}", c.id), (c.time, c.experience)))
+            .collect();
+        for e in self.recipe_book_entries() {
+            let furnace = |c: Category| match c.name().split('_').next() {
+                Some("blast") => RecipeKind::Blasting,
+                Some("smoker") => RecipeKind::Smoking,
+                _ => RecipeKind::Smelting,
+            };
+            let kind = match &e.display {
+                Display::Shaped { .. } => RecipeKind::CraftingShaped,
+                Display::Shapeless(_) => RecipeKind::CraftingShapeless,
+                Display::Furnace(_) => furnace(e.category),
+            };
+            let mut r = recipe(e.id.clone(), kind);
+            r.category = e.category.name().to_owned();
+            r.group = e.group.clone().unwrap_or_default();
+            r.book_id = e.display_id;
+            r.slots = match &e.display {
+                Display::Shaped {
+                    width,
+                    height,
+                    cells,
+                } => {
+                    (r.width, r.height) = (*width as u32, *height as u32);
+                    cells
+                        .iter()
+                        .map(|c| c.as_ref().map_or_else(Vec::new, |i| index.any(i)))
+                        .collect()
+                }
+                Display::Shapeless(list) => list.iter().map(|i| index.any(i)).collect(),
+                Display::Furnace(i) => vec![index.any(i)],
+            };
+            // Requirements shown as other stacks (an arrow's potions): the
+            // requirement's index counts the filled slots only.
+            let filled: Vec<usize> = (0..r.slots.len())
+                .filter(
+                    |&k| !matches!(&e.display, Display::Shaped { cells, .. } if cells[k].is_none()),
+                )
+                .collect();
+            for (req, stacks) in &e.stacks {
+                if let Some(&k) = filled.get(*req) {
+                    r.slots[k] = stacks.iter().filter_map(|s| index.of(s)).collect();
+                }
+            }
+            r.results = e.results().iter().filter_map(|s| index.of(s)).collect();
+            if let Some(&(time, xp)) = cooking.get(&e.id) {
+                (r.cooking_time, r.experience) = (time, xp);
+            }
+            out.push(r);
+        }
+        for c in &self.res.recipes().cooking {
+            if c.kind == "minecraft:campfire_cooking" {
+                let mut r = recipe(format!("minecraft:{}", c.id), RecipeKind::Campfire);
+                r.group = c.group.clone();
+                r.slots = vec![index.any(&c.ingredient)];
+                r.results = index.of(&c.result).into_iter().collect();
+                (r.cooking_time, r.experience) = (c.time, c.experience);
+                out.push(r);
+            }
+        }
+        let stations = self.res.stations();
+        for s in &stations.recipes.stonecutting {
+            let mut r = recipe(s.id.clone(), RecipeKind::Stonecutting);
+            r.slots = vec![index.any(&s.input)];
+            r.results = index.of(&s.result).into_iter().collect();
+            out.push(r);
+        }
+        for s in &stations.recipes.smithing {
+            let (id, template, base, addition, results) = match s {
+                Smithing::Transform {
+                    id,
+                    template,
+                    base,
+                    addition,
+                    result,
+                } => (
+                    id,
+                    template,
+                    base,
+                    addition,
+                    index.stack(result, 1, String::new()).into_iter().collect(),
+                ),
+                Smithing::Trim {
+                    id,
+                    template,
+                    base,
+                    addition,
+                    ..
+                } => (id, template, base, addition, index.any(base)),
+            };
+            let mut r = recipe(id.clone(), RecipeKind::Smithing);
+            r.slots = vec![index.any(template), index.any(base), index.any(addition)];
+            r.results = results;
+            out.push(r);
+        }
+        for b in &stations.brewing.recipes {
+            let potion = |p: &horizon_client::brewing::PotionIngredient| -> Vec<RecipeStack> {
+                let mut item_ids: Vec<&String> = p.items.iter().collect();
+                item_ids.sort();
+                let mut potions: Vec<&String> = p.potions.iter().flatten().collect();
+                potions.sort();
+                item_ids
+                    .into_iter()
+                    .flat_map(|item| {
+                        let one = |c: String| index.stack(item, 1, c);
+                        if potions.is_empty() {
+                            one(String::new()).into_iter().collect::<Vec<_>>()
+                        } else {
+                            potions
+                                .iter()
+                                .filter_map(|p| {
+                                    one(format!("[minecraft:potion_contents={{potion:\"{p}\"}}]"))
+                                })
+                                .collect()
+                        }
+                    })
+                    .collect()
+            };
+            let mut r = recipe(b.id.clone(), RecipeKind::Brewing);
+            r.slots = vec![potion(&b.input), potion(&b.reagent)];
+            r.results = index.of(&b.output).into_iter().collect();
+            out.push(r);
+        }
+        Recipes {
+            items: table,
+            recipes: out,
+        }
+    }
+}
diff --git a/crates/horizon-client/src/game/mods.rs b/crates/horizon-client/src/game/mods.rs
index d6e38dbbf..52dc46fe0 100644
--- a/crates/horizon-client/src/game/mods.rs
+++ b/crates/horizon-client/src/game/mods.rs
@@ -63,6 +63,14 @@ pub(super) struct ModsState {
     /// What players did this tick, for server mods at its end.
     #[cfg(feature = "mods")]
     pub(super) events: Vec<ModEvent>,
+    /// A running server mod has capability `world`: its calls get the
+    /// levels' chunks to read.
+    #[cfg(feature = "mods")]
+    pub(super) world: bool,
+    /// Blocks server mods set, by dimension, made before that level's next
+    /// tick.
+    #[cfg(feature = "mods")]
+    pub(super) block_writes: Vec<(String, horizon_mods::BlockChange)>,
     /// `command.run` lines for this window's own world, run on the next tick:
     /// run at once, their chat lines would reach the mods while their output
     /// is still being shown, and a mod answering its own lines would recurse.
@@ -81,6 +89,15 @@ pub(super) struct ModsState {
     /// The HUD font's advances for `render.text-width`, made once.
     #[cfg(feature = "mods")]
     font_widths: std::sync::Arc<[f32]>,
+    /// Capability `recipes`'s tables, made once a mod reads them.
+    #[cfg(feature = "mods")]
+    pub(super) recipes: Option<std::sync::Arc<horizon_mods::Recipes>>,
+    /// The recipe book's known displays, and the book's version they are of.
+    #[cfg(feature = "mods")]
+    pub(super) known_recipes: (Option<u64>, std::sync::Arc<[i32]>),
+    /// Capability `ui`'s item panel beside container screens.
+    #[cfg(feature = "mods")]
+    pub(super) browser: super::mod_browser::Browser,
     /// Extras that are official mods now, being installed.
     #[cfg(feature = "mods")]
     pub(super) moved: super::moved_extras::MovedState,
@@ -293,6 +310,8 @@ impl Game<'_> {
         self.mods.mods.set_bindings(|id| chosen.keys_of(id));
         // Entries were replaced wholesale: a screen's owner index is stale.
         self.mods.screen = None;
+        // Content mods may have changed the items: remade on the next read.
+        self.mods.recipes = None;
         self.list_mods();
         self.sync_mod_commands();
         self.show_mod_output();
@@ -309,6 +328,7 @@ impl Game<'_> {
     /// The Mods page's rows, from what loaded.
     fn list_mods(&mut self) {
         self.mods.server = self.mods.mods.runs_server();
+        self.mods.world = self.mods.mods.wants_world();
         let dev = &self.mods.dev;
         self.settings.mods.installed = self
             .mods
@@ -351,7 +371,10 @@ impl Game<'_> {
     }
     /// The chat's tree after the running mods changed.
     fn sync_mod_commands(&mut self) {
-        let mut names = self.mods.mods.commands().peekable();
+        // In-frame, the window runs server mods too: their names, free text
+        // here (the server parses their arguments).
+        let server = self.mods.mods.server_commands().map(|c| c.name.as_str());
+        let mut names = self.mods.mods.commands().chain(server).peekable();
         self.mods.tree = names
             .peek()
             .is_some()
@@ -440,6 +463,7 @@ impl Game<'_> {
                 .map(|c| char::from_u32(c).map_or(6.0, |c| atlas.glyph_cell(c).1))
                 .collect();
         }
+        let (recipes, known_recipes) = self.mod_recipes();
         Snapshot {
             player,
             clock,
@@ -451,6 +475,10 @@ impl Game<'_> {
             font_widths: self.mods.font_widths.clone(),
             players,
             view_hit: self.mod_view_hit(),
+            recipes,
+            known_recipes,
+            placing: self.mod_recipe_screen(),
+            creative: self.creative,
         }
     }
     /// The first block along the player's view within
@@ -673,8 +701,10 @@ impl Game<'_> {
                     }
                     Text::literal(line).with_color(text::RED)
                 }
-                server
-                @ (Output::Tell { .. } | Output::Broadcast { .. } | Output::Reply { .. }) => {
+                server @ (Output::Tell { .. }
+                | Output::Broadcast { .. }
+                | Output::Reply { .. }
+                | Output::SetBlocks { .. }) => {
                     self.route_server_output(host.as_deref_mut(), server);
                     continue;
                 }
@@ -686,6 +716,18 @@ impl Game<'_> {
                     self.mods.shake.add(strength, seconds);
                     continue;
                 }
+                Output::PlaceRecipe { book_id, all } => {
+                    self.mod_place_recipe(book_id, all);
+                    continue;
+                }
+                Output::Give {
+                    item,
+                    count,
+                    components,
+                } => {
+                    self.mod_give(&item, count, &components);
+                    continue;
+                }
                 Output::CloseScreen { owner } => {
                     if self.mods.screen.as_ref().is_some_and(|s| s.owner == owner) {
                         self.close_mod_screen(false);
diff --git a/crates/horizon-client/src/game/mounts.rs b/crates/horizon-client/src/game/mounts.rs
index fa4bbc209..617d86aaa 100644
--- a/crates/horizon-client/src/game/mounts.rs
+++ b/crates/horizon-client/src/game/mounts.rs
@@ -126,6 +126,19 @@ impl Game<'_> {
         if !equine::is_equine(species) || !m.alive() || Some(m.id) == self.riding {
             return false;
         }
+        // AbstractHorse.mobInteract: a horse a mob rides (`isVehicle`) has no
+        // seat, inventory or feeding to give. Camels seat two and check their
+        // passengers themselves.
+        let id = m.id;
+        if !matches!(species, Species::Camel | Species::CamelHusk)
+            && self
+                .mobs
+                .iter()
+                .any(|p| p.extra.mount == Some(id) && !p.removed && p.alive())
+        {
+            return false;
+        }
+        let m = &self.mobs[index];
         // AbstractHorse.mobInteract: shift + use opens a tamed adult's inventory.
         if !m.is_baby()
             && m.extra.tame
@@ -215,10 +228,12 @@ impl Game<'_> {
             return false;
         }
         let mut used = false;
+        let mut loved = false;
         if love && m.extra.tame && m.extra.age == 0 && m.extra.in_love <= 0 {
             m.extra.in_love = 600;
             m.extra.love_player = true;
             used = true;
+            loved = true;
         }
         if m.health < m.attrs.max_health && heal > 0.0 {
             m.health = (m.health + heal).min(m.attrs.max_health);
@@ -238,6 +253,7 @@ impl Game<'_> {
         // eating(): the mouth opens and the horse eats.
         m.anim.v[2] = 1.0;
         let at = m.center();
+        let id = m.id;
         let sound = match m.species() {
             Species::Camel => "minecraft:entity.camel.eat",
             Species::CamelHusk => "minecraft:entity.camel_husk.eat",
@@ -247,6 +263,10 @@ impl Game<'_> {
         };
         let pitch = (self.world.random.next_float() - self.world.random.next_float()) * 0.2 + 1.0;
         self.audio.play(sound, Some(at), 1.0, pitch);
+        // Animal.setInLove: entity event 18.
+        if loved {
+            self.mob_event_particles(id, 18);
+        }
         self.consume_held();
         true
     }
@@ -452,14 +472,16 @@ impl Game<'_> {
                     m.extra.owner = owner;
                     m.persistent = true;
                     // AbstractHorse.tameWithName: entity event 7, spawnTamingParticles(true).
-                    self.particles_around_mob(
-                        mob,
-                        "heart",
-                        horizon_client::particles::Burst::TAMING,
-                    );
+                    self.mob_event_particles(mob, 7);
                 }
             }
-            MobEvent::Buck { mob } if self.riding == Some(mob) => self.dismount_mount(),
+            MobEvent::Buck { mob } => {
+                if self.riding == Some(mob) {
+                    self.dismount_mount();
+                }
+                // RunAroundLikeCrazyGoal.tick: entity event 6, smoke.
+                self.mob_event_particles(mob, 6);
+            }
             _ => {}
         }
     }
diff --git a/crates/horizon-client/src/game/moving_pistons.rs b/crates/horizon-client/src/game/moving_pistons.rs
index 17247850e..e1bdf89d0 100644
--- a/crates/horizon-client/src/game/moving_pistons.rs
+++ b/crates/horizon-client/src/game/moving_pistons.rs
@@ -14,7 +14,9 @@ impl Game<'_> {
         out: &mut Vec<Vertex>,
     ) {
         let partial = alpha as f32;
-        for &(p, piston) in &self.world.moving_pistons {
+        let mut states = self.world.moving_pistons.clone();
+        states.extend(self.world.moving_piston_fallback.iter().copied());
+        for (p, piston) in states {
             let Some((block, base)) = self.moving_piston_blocks(piston, partial) else {
                 continue;
             };
diff --git a/crates/horizon-client/src/game/music.rs b/crates/horizon-client/src/game/music.rs
index 6f8b5e7ae..97ca3763e 100644
--- a/crates/horizon-client/src/game/music.rs
+++ b/crates/horizon-client/src/game/music.rs
@@ -3,7 +3,7 @@
 use super::Game;
 use horizon_client::{
     blocks::Fluid,
-    music::{BackgroundMusic, Music, Situation},
+    music::{BackgroundMusic, Music, MusicFrequency, Situation},
     sound_engine::TickContext,
 };
 
@@ -11,6 +11,11 @@ impl Game<'_> {
     /// `Minecraft.tick` -> `MusicManager.tick`, once per client tick.
     pub(super) fn tick_music(&mut self) {
         let (music, volume) = self.situational_music();
+        // Options.musicFrequency's listener: MusicManager.setMinutesBetweenSongs.
+        let frequency = MusicFrequency::parse(&self.settings.file.name("musicFrequency"));
+        if frequency != self.music.frequency {
+            self.music.set_frequency(frequency, music.as_ref());
+        }
         // LevelLoadingScreen: no new track before the player is in the world.
         let loading = self.title.is_none() && self.player.is_none() && self.win.is_none();
         self.music
@@ -91,7 +96,7 @@ impl Game<'_> {
             })
     }
     /// `isEyeInFluid(WATER)`: the eye inside the water of its block column.
-    fn eye_in_water(&self, x: f64, eye_y: f64, z: f64) -> bool {
+    pub(super) fn eye_in_water(&self, x: f64, eye_y: f64, z: f64) -> bool {
         let (bx, by, bz) = (x.floor() as i32, eye_y.floor() as i32, z.floor() as i32);
         let f = self.res.facts().get(self.world.block(bx, by, bz));
         if f.fluid != Fluid::Water {
diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs
index 9f7561e53..3ecd2d245 100644
--- a/crates/horizon-client/src/game/names.rs
+++ b/crates/horizon-client/src/game/names.rs
@@ -338,7 +338,9 @@ impl Game<'_> {
             let (r, u) = (right.as_vec3() * 0.025, up.as_vec3() * 0.025);
             // Text space: x right, y down (scale 0.025, -0.025).
             let at = |x: f32, y: f32| o + r * x - u * y;
-            let chars: Vec<(char, u32)> = text
+            // Component.getVisualOrderText.
+            let shown = horizon_client::bidi::visual(text);
+            let chars: Vec<(char, u32)> = shown
                 .spans
                 .iter()
                 .flat_map(|s| {
@@ -377,6 +379,7 @@ impl Game<'_> {
                         layer,
                         color,
                         light,
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             };
diff --git a/crates/horizon-client/src/game/natural_spawning.rs b/crates/horizon-client/src/game/natural_spawning.rs
index 0035f5082..5afa72416 100644
--- a/crates/horizon-client/src/game/natural_spawning.rs
+++ b/crates/horizon-client/src/game/natural_spawning.rs
@@ -504,7 +504,8 @@ impl<'a> Game<'a> {
                         m.position.z.floor() as i32,
                     ],
                     is_mob: true,
-                    persistent: m.persistent,
+                    persistent: m.persistent
+                        || horizon_client::mobs::ai::requires_custom_persistence(m),
                 })
                 .collect();
             let players = players
diff --git a/crates/horizon-client/src/game/nautili.rs b/crates/horizon-client/src/game/nautili.rs
index e7f16ca18..5e384db98 100644
--- a/crates/horizon-client/src/game/nautili.rs
+++ b/crates/horizon-client/src/game/nautili.rs
@@ -85,13 +85,8 @@ impl Game<'_> {
                     m.ai.target = None;
                 }
                 let sound = nautilus::eat_sound(m);
-                let kind = if tamed { "heart" } else { "smoke" };
                 // TamableAnimal.spawnTamingParticles (entity event 7 or 6).
-                self.particles_around_mob(
-                    self.mobs[index].id,
-                    kind,
-                    horizon_client::particles::Burst::TAMING,
-                );
+                self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 });
                 self.nautilus_sound(index, sound);
                 if tamed {
                     let view = self.mob_entity(&self.mobs[index]);
@@ -145,6 +140,8 @@ impl Game<'_> {
             let sound = nautilus::eat_sound(m);
             self.use_nautilus_food(item);
             self.nautilus_sound(index, sound);
+            // Animal.setInLove: entity event 18.
+            self.mob_event_particles(self.mobs[index].id, 18);
             return true;
         }
         false
diff --git a/crates/horizon-client/src/game/nether_portal.rs b/crates/horizon-client/src/game/nether_portal.rs
index 87ba81c93..c8142284a 100644
--- a/crates/horizon-client/src/game/nether_portal.rs
+++ b/crates/horizon-client/src/game/nether_portal.rs
@@ -2,7 +2,9 @@
 //! `Entity.setAsInsidePortal` / `handlePortal` with `PortalProcessor`,
 //! `NetherPortalBlock.getPortalTransitionTime` and `getPortalDestination`
 //! (`PortalForcer` through `horizon_world::level::portal_travel`), and
-//! `LocalPlayer.handlePortalTransitionEffect`.
+//! `LocalPlayer.handlePortalTransitionEffect`. Items and mobs also go through
+//! End portals here (`EndPortalBlock.entityInside` / `getPortalDestination`);
+//! the player's End portals are game/end.rs's.
 //!
 //! Only one dimension is loaded at a time. The player's destination is found
 //! once the other dimension has loaded around it. An item or mob that goes
@@ -12,7 +14,7 @@ use super::{Dim, Game, Screen};
 use horizon_client::Result;
 use horizon_client::nether_portal::PortalState;
 use horizon_core::{
-    geometry::{Axis, Vec3},
+    geometry::{Aabb, Axis, Vec3},
     position::BlockPos,
     random::RandomSource,
 };
@@ -40,6 +42,32 @@ pub(super) struct Plan {
     offset: Vec3,
     width: f32,
     height: f32,
+    /// Through an End portal: `approximate` is the End's spawn point, or the
+    /// Overworld's shared spawn.
+    end: bool,
+}
+
+impl Plan {
+    /// `EndPortalBlock.getPortalDestination` for an entity other than a
+    /// player in `from`: the End's spawn point, or out of the End the
+    /// Overworld's shared spawn `world_spawn`.
+    fn end_portal(from: Dim, world_spawn: BlockPos, width: f32, height: f32) -> Self {
+        let (dim, approximate) = if from == Dim::End {
+            (Dim::Overworld, world_spawn)
+        } else {
+            let [x, y, z] = super::end::END_SPAWN;
+            (Dim::End, BlockPos::new(x, y, z))
+        };
+        Self {
+            dim,
+            approximate,
+            entry_x_axis: true,
+            offset: Vec3::ZERO,
+            width,
+            height,
+            end: true,
+        }
+    }
 }
 
 /// An entity on its way to a dimension that isn't loaded.
@@ -81,6 +109,89 @@ fn rotate_y(v: Vec3, degrees: f32) -> Vec3 {
 fn doubles(values: [f64; 3]) -> Tag {
     Tag::List(values.iter().map(|v| Tag::Double(v.to_bits())).collect())
 }
+/// Whether a `width` by `height` box moving from `from` to `to` meets the End
+/// portal at `pos`: `Entity.collidedWithShapeMovingFrom` against its
+/// entity-inside shape, y 6/16..12/16 of the block.
+fn touches_end_portal(from: Vec3, to: Vec3, width: f32, height: f32, pos: BlockPos) -> bool {
+    let half = f64::from(width) / 2.0;
+    let start = Aabb::new(
+        Vec3::new(from.x - half, from.y, from.z - half),
+        Vec3::new(from.x + half, from.y + f64::from(height), from.z + half),
+    );
+    let (x, y, z) = (f64::from(pos.x), f64::from(pos.y), f64::from(pos.z));
+    let shape = Aabb::new(
+        Vec3::new(x, y + 0.375, z),
+        Vec3::new(x + 1.0, y + 0.75, z + 1.0),
+    );
+    start.collided_along_vector(to.subtract(from), &[shape])
+}
+/// `PositionMoveRotation.calculateAbsolute` for an End portal's transition
+/// of an entity facing `[yaw, pitch]`: into the End it faces west and keeps
+/// its pitch (`Relative.X_ROT`); out of it both turn by the world spawn's
+/// angles (`Relative.ROTATION`). The pitch stays within ±90.
+fn end_portal_rotation(into_end: bool, [yaw, pitch]: [f32; 2], spawn: [f32; 2]) -> [f32; 2] {
+    let (yaw, pitch) = if into_end {
+        // Direction.WEST.toYRot().
+        (90.0, pitch)
+    } else {
+        (yaw + spawn[0], pitch + spawn[1])
+    };
+    [yaw, pitch.clamp(-90.0, 90.0)]
+}
+/// A waiting entity as `horizon_portal_arrivals.dat` keeps it.
+fn arrival_tag(a: &Arrival) -> Tag {
+    let p = &a.plan;
+    Tag::compound([
+        ("dimension", Tag::String(p.dim.id().into())),
+        ("x", Tag::Int(p.approximate.x)),
+        ("y", Tag::Int(p.approximate.y)),
+        ("z", Tag::Int(p.approximate.z)),
+        ("x_axis", Tag::Int(i32::from(p.entry_x_axis))),
+        ("right", Tag::Double(p.offset.x.to_bits())),
+        ("up", Tag::Double(p.offset.y.to_bits())),
+        ("forward", Tag::Double(p.offset.z.to_bits())),
+        ("width", Tag::Float(p.width.to_bits())),
+        ("height", Tag::Float(p.height.to_bits())),
+        ("end", Tag::Int(i32::from(p.end))),
+        ("entity", a.tag.clone()),
+    ])
+}
+/// The waiting entity `arrival_tag` wrote.
+fn arrival_from_tag(a: &Tag) -> Option<Arrival> {
+    let int = |k: &str| match a.get(k) {
+        Some(Tag::Int(v)) => Some(*v),
+        _ => None,
+    };
+    let float = |k: &str| match a.get(k) {
+        Some(Tag::Float(v)) => Some(f32::from_bits(*v)),
+        _ => None,
+    };
+    let double = |k: &str| match a.get(k) {
+        Some(Tag::Double(v)) => Some(f64::from_bits(*v)),
+        _ => None,
+    };
+    let dim = Dim::from_id(&horizon_client::save::text(a.get("dimension"))?);
+    let (Some(x), Some(y), Some(z), Some(tag)) = (int("x"), int("y"), int("z"), a.get("entity"))
+    else {
+        return None;
+    };
+    Some(Arrival {
+        plan: Plan {
+            dim,
+            approximate: BlockPos::new(x, y, z),
+            entry_x_axis: int("x_axis").unwrap_or(1) != 0,
+            offset: Vec3::new(
+                double("right").unwrap_or(0.5),
+                double("up").unwrap_or(0.0),
+                double("forward").unwrap_or(0.0),
+            ),
+            width: float("width").unwrap_or(0.25),
+            height: float("height").unwrap_or(0.25),
+            end: int("end").unwrap_or(0) != 0,
+        },
+        tag: tag.clone(),
+    })
+}
 
 impl Game<'_> {
     /// The world border's extent.
@@ -146,8 +257,54 @@ impl Game<'_> {
             offset,
             width,
             height,
+            end: false,
         }
     }
+    /// The plan of an item or mob going through the portal block at `entry`:
+    /// an End portal's fixed destination, else the Nether portal's.
+    fn entity_plan(
+        &self,
+        entry: BlockPos,
+        at: Vec3,
+        width: f32,
+        height: f32,
+        reset_forward: bool,
+    ) -> Plan {
+        if !self.is_end_portal(self.world.block(entry.x, entry.y, entry.z)) {
+            return self.portal_plan(entry, at, width, height, reset_forward);
+        }
+        let spawn = self.level.world_spawn.unwrap_or_else(|| {
+            self.spawn.map_or([0, 64, 0], |s| {
+                [s.x.floor() as i32, s.y.floor() as i32, s.z.floor() as i32]
+            })
+        });
+        Plan::end_portal(
+            self.dim,
+            BlockPos::new(spawn[0], spawn[1], spawn[2]),
+            width,
+            height,
+        )
+    }
+    fn is_end_portal(&self, state: horizon_world::registry::BlockStateId) -> bool {
+        &*self.res.facts().get(state).name == "minecraft:end_portal"
+    }
+    /// Where an item or mob through an End portal lands once `plan`'s level
+    /// has loaded around it: the bottom centre of the End's spawn point,
+    /// above the platform built below it (`EndPlatformFeature.createEndPlatform`);
+    /// out of the End, the top of the shared spawn's column
+    /// (`Entity.adjustSpawnLocation`).
+    fn end_portal_exit(&mut self, plan: &Plan) -> Vec3 {
+        let p = plan.approximate;
+        let centre = Vec3::new(f64::from(p.x) + 0.5, f64::from(p.y), f64::from(p.z) + 0.5);
+        if plan.dim == Dim::End {
+            if let Err(e) = self.end_arrival(centre) {
+                log::error!("End platform: {e}");
+            }
+            return centre;
+        }
+        let y = self.motion_top(p.x, p.z);
+        Vec3::new(centre.x, f64::from(y), centre.z)
+    }
     /// The nether portal blocks of the chunks within `radius` of `center`
     /// (the points of interest `PortalForcer` searches): loaded chunks as
     /// they are, the others as saved; chunks never generated have none.
@@ -520,9 +677,10 @@ impl Game<'_> {
             || self.ridden_by_guest(id)
             || self.mobs.iter().any(|m| m.extra.mount == Some(id))
     }
-    /// `NetherPortalBlock.entityInside` for the items, mobs and empty boats
-    /// and minecarts that moved this tick: the portal blocks their box swept
-    /// through.
+    /// `NetherPortalBlock.entityInside` and `EndPortalBlock.entityInside`
+    /// for the items, mobs and empty boats and minecarts that moved this
+    /// tick: the portal blocks their box swept through (an End portal's
+    /// transition time is 0 too).
     pub(super) fn find_entity_portals(&mut self) {
         if self.remote.is_some() {
             return;
@@ -570,7 +728,7 @@ impl Game<'_> {
                 .set_inside(pos, ENTITY_DELAY);
         }
     }
-    /// The first nether portal block an entity box swept through
+    /// The first nether or End portal block an entity box swept through
     /// (`Entity.checkInsideBlocks`, whose first portal sets the entry).
     fn swept_portal(
         &self,
@@ -604,11 +762,9 @@ impl Game<'_> {
             bounds,
             1_000_000,
             |p, _| {
-                if self
-                    .res
-                    .behaviours()
-                    .portal_axis(self.world.block(p.x, p.y, p.z))
-                    .is_some()
+                let state = self.world.block(p.x, p.y, p.z);
+                if self.res.behaviours().portal_axis(state).is_some()
+                    || (self.is_end_portal(state) && touches_end_portal(from, to, width, height, p))
                 {
                     found = Some(p);
                     return false;
@@ -618,8 +774,8 @@ impl Game<'_> {
         );
         found
     }
-    /// Whether a section `reach` touches has a nether portal state in its
-    /// palette: without one, no block there is a portal. Palette answers are
+    /// Whether a section `reach` touches has a nether or End portal state in
+    /// its palette: without one, no block there is a portal. Palette answers are
     /// kept per chunk across ticks (`portal_sections`); a box over many
     /// sections is not checked.
     fn may_hold_portal(
@@ -656,9 +812,8 @@ impl Game<'_> {
             (z0..=z1).any(|cz| {
                 chunks.get(&(cx, cz)).is_some_and(|chunk| {
                     sections.get((cx, cz), chunk, |v| {
-                        behaviours
-                            .portal_axis(horizon_world::registry::BlockStateId(v))
-                            .is_some()
+                        let state = horizon_world::registry::BlockStateId(v);
+                        behaviours.portal_axis(state).is_some() || self.is_end_portal(state)
                     }) & y_mask
                         != 0
                 })
@@ -670,7 +825,7 @@ impl Game<'_> {
     fn send_through_portal(&mut self, id: u32, entry: BlockPos) {
         if let Some(i) = self.dropped.iter().position(|e| e.id == id) {
             let e = &self.dropped[i];
-            let plan = self.portal_plan(entry, e.position, 0.25, 0.25, false);
+            let plan = self.entity_plan(entry, e.position, 0.25, 0.25, false);
             if !self.may_enter(plan.dim) {
                 return;
             }
@@ -686,7 +841,7 @@ impl Game<'_> {
             self.portals.dirty = true;
         } else if let Some(i) = self.mobs.iter().position(|m| m.id == id) {
             let m = &self.mobs[i];
-            let plan = self.portal_plan(entry, m.position, m.width(), m.height(), true);
+            let plan = self.entity_plan(entry, m.position, m.width(), m.height(), true);
             if !self.may_enter(plan.dim) {
                 return;
             }
@@ -716,7 +871,7 @@ impl Game<'_> {
         } else if let Some(i) = self.boats.iter().position(|b| b.id == id) {
             let b = &self.boats[i];
             let (width, height) = (super::boats::WIDTH as f32, super::boats::HEIGHT as f32);
-            let plan = self.portal_plan(entry, b.position, width, height, false);
+            let plan = self.entity_plan(entry, b.position, width, height, false);
             if !self.may_enter(plan.dim) {
                 return;
             }
@@ -741,7 +896,7 @@ impl Game<'_> {
                 super::minecarts::WIDTH as f32,
                 super::minecarts::HEIGHT as f32,
             );
-            let plan = self.portal_plan(entry, c.position, width, height, false);
+            let plan = self.entity_plan(entry, c.position, width, height, false);
             if !self.may_enter(plan.dim) {
                 return;
             }
@@ -754,8 +909,8 @@ impl Game<'_> {
         }
     }
     /// Entities waiting for the loaded dimension whose exit area is loaded:
-    /// their exit portal (found or built), position, turned yaw and motion,
-    /// and portal cooldown; they join the world with the chunk entities.
+    /// their exit portal (found or built) or End destination, position,
+    /// turned yaw and motion, and portal cooldown; they join the world with the chunk entities.
     pub(super) fn resolve_arrivals(&mut self) {
         if self.remote.is_some() {
             return;
@@ -772,21 +927,28 @@ impl Game<'_> {
             }
             let Arrival { plan, mut tag } = self.portals.arrivals.remove(i);
             self.portals.dirty = true;
-            let Some(exit) = self.nether_exit_portal(&plan) else {
-                continue;
-            };
-            let (at, rotation) = self.arrival(&plan, exit);
-            let motion = rotate_y(horizon_client::entity_nbt::motion(&tag), -rotation);
+            let motion = horizon_client::entity_nbt::motion(&tag);
             let [yaw, pitch] = horizon_client::entity_nbt::rotation(&tag);
+            let (at, motion, [yaw, pitch]) = if plan.end {
+                // Relative.DELTA: the motion is kept.
+                let at = self.end_portal_exit(&plan);
+                let into_end = plan.dim == Dim::End;
+                let turn =
+                    end_portal_rotation(into_end, [yaw, pitch], self.level.world_spawn_angle);
+                (at, motion, turn)
+            } else {
+                let Some(exit) = self.nether_exit_portal(&plan) else {
+                    continue;
+                };
+                let (at, rotation) = self.arrival(&plan, exit);
+                (at, rotate_y(motion, -rotation), [yaw + rotation, pitch])
+            };
             if let Tag::Compound(c) = &mut tag {
                 c.insert("Pos".into(), doubles([at.x, at.y, at.z]));
                 c.insert("Motion".into(), doubles([motion.x, motion.y, motion.z]));
                 c.insert(
                     "Rotation".into(),
-                    Tag::List(vec![
-                        Tag::Float((yaw + rotation).to_bits()),
-                        Tag::Float(pitch.to_bits()),
-                    ]),
+                    Tag::List(vec![Tag::Float(yaw.to_bits()), Tag::Float(pitch.to_bits())]),
                 );
                 // setPortalCooldown before the teleport, copied by restoreFrom.
                 c.insert("PortalCooldown".into(), Tag::Int(ENTITY_DELAY));
@@ -823,75 +985,117 @@ impl Game<'_> {
         let Some(Tag::List(list)) = root.get("arrivals") else {
             return;
         };
-        for a in list {
-            let int = |k: &str| match a.get(k) {
-                Some(Tag::Int(v)) => Some(*v),
-                _ => None,
-            };
-            let float = |k: &str| match a.get(k) {
-                Some(Tag::Float(v)) => Some(f32::from_bits(*v)),
-                _ => None,
-            };
-            let double = |k: &str| match a.get(k) {
-                Some(Tag::Double(v)) => Some(f64::from_bits(*v)),
-                _ => None,
-            };
-            let dim = match horizon_client::save::text(a.get("dimension")).as_deref() {
-                Some("minecraft:the_nether") => Dim::Nether,
-                Some(_) => Dim::Overworld,
-                None => continue,
-            };
-            let (Some(x), Some(y), Some(z), Some(tag)) =
-                (int("x"), int("y"), int("z"), a.get("entity"))
-            else {
-                continue;
-            };
-            self.portals.arrivals.push(Arrival {
-                plan: Plan {
-                    dim,
-                    approximate: BlockPos::new(x, y, z),
-                    entry_x_axis: int("x_axis").unwrap_or(1) != 0,
-                    offset: Vec3::new(
-                        double("right").unwrap_or(0.5),
-                        double("up").unwrap_or(0.0),
-                        double("forward").unwrap_or(0.0),
-                    ),
-                    width: float("width").unwrap_or(0.25),
-                    height: float("height").unwrap_or(0.25),
-                },
-                tag: tag.clone(),
-            });
-        }
+        self.portals
+            .arrivals
+            .extend(list.iter().filter_map(arrival_from_tag));
     }
     /// Write the waiting entities when they changed.
     pub(super) fn save_portal_arrivals(&mut self) {
         if !self.portals.dirty || self.remote.is_some() {
             return;
         }
-        let list = self
-            .portals
-            .arrivals
-            .iter()
-            .map(|a| {
-                let p = &a.plan;
-                Tag::compound([
-                    ("dimension", Tag::String(p.dim.id().into())),
-                    ("x", Tag::Int(p.approximate.x)),
-                    ("y", Tag::Int(p.approximate.y)),
-                    ("z", Tag::Int(p.approximate.z)),
-                    ("x_axis", Tag::Int(i32::from(p.entry_x_axis))),
-                    ("right", Tag::Double(p.offset.x.to_bits())),
-                    ("up", Tag::Double(p.offset.y.to_bits())),
-                    ("forward", Tag::Double(p.offset.z.to_bits())),
-                    ("width", Tag::Float(p.width.to_bits())),
-                    ("height", Tag::Float(p.height.to_bits())),
-                    ("entity", a.tag.clone()),
-                ])
-            })
-            .collect();
+        let list = self.portals.arrivals.iter().map(arrival_tag).collect();
         let root = Tag::compound([("arrivals", Tag::List(list))]);
         if horizon_client::save::write_dat(&self.arrivals_path(), root).is_ok() {
             self.portals.dirty = false;
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn end_portals_lead_to_the_end_spawn_and_back_to_the_world_spawn() {
+        let spawn = BlockPos::new(-7, 70, 12);
+        for from in [Dim::Overworld, Dim::Nether] {
+            let plan = Plan::end_portal(from, spawn, 0.9, 1.4);
+            assert_eq!(plan.dim, Dim::End);
+            assert_eq!(plan.approximate, BlockPos::new(100, 50, 0));
+            assert!(plan.end);
+        }
+        let plan = Plan::end_portal(Dim::End, spawn, 0.25, 0.25);
+        assert_eq!(plan.dim, Dim::Overworld);
+        assert_eq!(plan.approximate, spawn);
+    }
+
+    #[test]
+    fn the_end_portal_shape_takes_falling_items_and_standing_mobs() {
+        let portal = BlockPos::new(0, 100, 3);
+        let at = |y| Vec3::new(0.5, y, 3.5);
+        // A dropped item falling through the slab, or in it.
+        assert!(touches_end_portal(
+            at(100.6),
+            at(100.56),
+            0.25,
+            0.25,
+            portal
+        ));
+        // One tick's fall across the whole slab, in it at neither end.
+        assert!(touches_end_portal(at(101.0), at(99.9), 0.25, 0.25, portal));
+        // Resting below the slab (on the floor) or above it.
+        assert!(!touches_end_portal(
+            at(100.0),
+            at(100.0),
+            0.25,
+            0.25,
+            portal
+        ));
+        assert!(!touches_end_portal(
+            at(100.8),
+            at(100.8),
+            0.25,
+            0.25,
+            portal
+        ));
+        // A cow standing in the portal block.
+        assert!(touches_end_portal(at(100.0), at(100.0), 0.9, 1.4, portal));
+        // Beside it.
+        let beside = Vec3::new(2.0, 100.0, 3.5);
+        assert!(!touches_end_portal(beside, beside, 0.9, 1.4, portal));
+    }
+
+    #[test]
+    fn end_portals_turn_entities_like_their_teleport_transition() {
+        // Into the End: facing west, pitch kept.
+        assert_eq!(
+            end_portal_rotation(true, [-30.0, 20.0], [45.0, 10.0]),
+            [90.0, 20.0]
+        );
+        // Out of it: turned by the world spawn's yaw and pitch, pitch clamped.
+        assert_eq!(
+            end_portal_rotation(false, [-30.0, 20.0], [45.0, 10.0]),
+            [15.0, 30.0]
+        );
+        assert_eq!(
+            end_portal_rotation(false, [0.0, 80.0], [0.0, 30.0]),
+            [0.0, 90.0]
+        );
+    }
+
+    #[test]
+    fn waiting_arrivals_keep_their_end_destination_when_saved() {
+        let tag = Tag::compound([("id", Tag::String("minecraft:cow".into()))]);
+        for (from, dim) in [(Dim::Overworld, Dim::End), (Dim::End, Dim::Overworld)] {
+            let arrival = Arrival {
+                plan: Plan::end_portal(from, BlockPos::new(3, 64, -5), 0.9, 1.4),
+                tag: tag.clone(),
+            };
+            let back = arrival_from_tag(&arrival_tag(&arrival)).unwrap();
+            assert_eq!(back.plan.dim, dim);
+            assert_eq!(back.plan.approximate, arrival.plan.approximate);
+            assert!(back.plan.end);
+            assert_eq!(back.tag, tag);
+        }
+        // Arrivals saved before End portals were Nether portal plans.
+        let mut old = arrival_tag(&Arrival {
+            plan: Plan::end_portal(Dim::End, BlockPos::new(0, 64, 0), 0.25, 0.25),
+            tag,
+        });
+        if let Tag::Compound(c) = &mut old {
+            c.remove(&"end".into());
+        }
+        assert!(!arrival_from_tag(&old).unwrap().plan.end);
+    }
+}
diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs
index 569c63083..013b94de2 100644
--- a/crates/horizon-client/src/game/packs.rs
+++ b/crates/horizon-client/src/game/packs.rs
@@ -1,14 +1,23 @@
 //! Resource pack selection bound to the game: the pack screen lists, and a
 //! full resource reload after a change, while playing.
-use super::Game;
+use super::{
+    Game, PackResources, Resources, UiResources, build_renderer, prepare_renderer_textures,
+};
 use horizon_client::{
+    assets::Assets,
+    gfx::PreparedTextures,
     hud::HudAtlas,
     lang,
     pack_screen::{self, Compat, PackInfo, Source as PackSource},
     packs::{self, Pack, Position},
+    streaming::WorkerContext,
     text::{Style, Text},
 };
-use std::path::{Path, PathBuf};
+use std::{
+    collections::BTreeSet,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
 
 /// Where overlay roots are built (beside options.txt).
 pub fn cache_dir() -> PathBuf {
@@ -34,6 +43,10 @@ pub fn open_folder(dir: &Path) {
         log::warn!("Horizon: could not open {}: {e}", dir.display());
     }
 }
+/// `Util.getPlatform().openUri`: the system browser on the link.
+pub fn open_uri(uri: &str) {
+    open_folder(Path::new(uri));
+}
 /// The resource root to load from, given the vanilla root, the selection and
 /// a server's packs, which go on top (`Pack.Position.TOP`, fixed).
 pub fn startup_root(
@@ -94,7 +107,7 @@ pub(super) fn pack_infos(vanilla: &Path) -> Vec<PackInfo> {
     infos
 }
 impl Game<'_> {
-    fn vanilla_root(&self) -> PathBuf {
+    pub(super) fn vanilla_root(&self) -> PathBuf {
         if self.ui.vanilla_root.as_os_str().is_empty() {
             self.options.resources.clone()
         } else {
@@ -134,35 +147,36 @@ impl Game<'_> {
             self.ui.options.resource_error = Some(e.to_string());
         }
     }
-    /// Reload from the selected packs and the server's.
-    pub(super) fn reload_selected_packs(&mut self) -> horizon_client::Result<()> {
+    /// The CPU half of the reload, safe on a worker (`PackReload` runs it):
+    /// `apply_staged_pack` finishes the GPU half and the swap.
+    pub(super) fn stage_selected_packs(&mut self) -> horizon_client::Result<StagedPack> {
         let vanilla = self.vanilla_root();
         if self.ui.vanilla_root.as_os_str().is_empty() {
             self.ui.vanilla_root = vanilla.clone();
         }
-        let server = &self.server_packs.active;
-        let root = startup_root(&vanilla, &self.settings.resource_packs, server)?;
-        let root =
-            super::mods::content_root(&root, &self.settings.mods.enabled, &self.options.dev_mods);
-        self.reload_resources(&root)
+        stage_pack(
+            &vanilla,
+            &self.settings.resource_packs,
+            &self.server_packs.active,
+            &self.settings.mods.enabled,
+            &self.options.dev_mods,
+            &self.pack.assets,
+            &self.res,
+            &self.pack.context,
+            self.settings.force_unicode,
+            self.settings.japanese_glyphs,
+            &super::Progress::new(),
+        )
     }
-    fn reload_resources(&mut self, root: &Path) -> horizon_client::Result<()> {
-        let render = std::sync::Arc::new(self.pack.assets.reload(root)?);
-        let mut atlas = HudAtlas::build_over(root, &self.vanilla_root())?;
-        atlas.font.uniform = self.settings.force_unicode;
-        atlas.font.japanese = self.settings.japanese_glyphs;
-        let gui = super::UiResources {
-            atlas,
-            panorama: std::sync::Arc::new(horizon_client::gfx::panorama::Faces::load(root)),
-        };
-        let pack = super::PackResources::load(
+    /// The render-thread half: the renderer on the new pack's textures, then
+    /// the swap (`ReloadInstance`'s application listeners).
+    pub(super) fn apply_staged_pack(&mut self, staged: StagedPack) -> horizon_client::Result<()> {
+        let StagedPack {
             root,
-            self.pack.assets.clone(),
-            render,
-            self.res.facts(),
-            self.pack.context.biomes.clone(),
-            self.pack.context.light.clone(),
-        )?;
+            gui,
+            pack,
+            textures,
+        } = staged;
         // Keep the working GPU resources, and hand its window surface over.
         if let Some(renderer) = &mut self.renderer {
             renderer.release_surface();
@@ -170,7 +184,17 @@ impl Game<'_> {
         let renderer = match self
             .window
             .clone()
-            .map(|window| self.renderer_for(window, &pack, &gui))
+            .map(|window| {
+                build_renderer(
+                    window,
+                    self.options.offscreen,
+                    &pack,
+                    &gui,
+                    self.renderer.as_ref(),
+                    Some(textures),
+                    self.settings.horizon.api,
+                )
+            })
             .transpose()
         {
             Ok(renderer) => renderer,
@@ -186,18 +210,18 @@ impl Game<'_> {
             }
         };
         // Everything loaded: switch over.
-        self.waypoint_styles = horizon_client::locator_bar::WaypointStyles::load(root);
-        self.armor_stand_assets.reload_trims(root);
+        self.waypoint_styles = horizon_client::locator_bar::WaypointStyles::load(&root);
+        self.armor_stand_assets.reload_trims(&root);
         self.random_tick_sections.clear();
         self.portals.sections.clear();
-        self.options.resources = root.to_path_buf();
+        self.options.resources = root.clone();
         let context = pack.context.clone();
         self.pack = pack;
         self.gui = gui;
         // The atlas's sprites moved: the particle engine re-reads every rect
         // and the packs' sprite sets, or every particle draws a stale region.
         self.particles
-            .reload(root, &self.gui.atlas.sprites, &self.gui.atlas.translucent);
+            .reload(&root, &self.gui.atlas.sprites, &self.gui.atlas.translucent);
         horizon_client::ui_theme::reset_atlas();
         // Villager hats come from the pack's texture metadata (shared data, swapped in place).
         *self
@@ -206,11 +230,11 @@ impl Game<'_> {
             .villager_hats
             .write()
             .unwrap_or_else(std::sync::PoisonError::into_inner) =
-            horizon_client::mobs::villager_hats::VillagerHats::load(root);
-        horizon_client::ui::load_metadata(root);
-        lang::set(lang::Language::load(&[&root.to_path_buf()], &lang::code()));
+            horizon_client::mobs::villager_hats::VillagerHats::load(&root);
+        horizon_client::ui::load_metadata(&root);
+        lang::set(lang::Language::load(&[&root], &lang::code()));
         self.refresh_remote_language();
-        self.audio.reload(root);
+        self.audio.reload(&root);
         self.clear_lod();
         self.streaming.reload_resources(&mut self.world, context);
         self.pending_uploads.clear();
@@ -225,4 +249,66 @@ impl Game<'_> {
         self.creative_screen.forget_items();
         Ok(())
     }
+    /// `Minecraft.reloadResourcePacks`: the reload staged on the spot, then
+    /// applied (`PackReload` runs the same two phases across frames).
+    pub(super) fn reload_selected_packs(&mut self) -> horizon_client::Result<()> {
+        let staged = self.stage_selected_packs()?;
+        self.apply_staged_pack(staged)
+    }
+}
+
+/// The CPU half of `reload_selected_packs` (`PackReload` runs it on a
+/// worker; `apply_staged_pack` does the GPU half and the swap): the overlay
+/// root, the models and sprites, the menu bundle, the pack's tables and its
+/// CPU mip chains.
+pub(super) fn stage_pack(
+    vanilla_root: &Path,
+    selected: &[String],
+    server: &[Pack],
+    mods_enabled: &BTreeSet<String>,
+    dev_mods: &[PathBuf],
+    assets: &Arc<Assets>,
+    res: &Resources,
+    context: &WorkerContext,
+    force_unicode: bool,
+    japanese: bool,
+    progress: &super::Progress,
+) -> horizon_client::Result<StagedPack> {
+    let root = startup_root(vanilla_root, selected, server)?;
+    let root = super::mods::content_root(&root, mods_enabled, dev_mods);
+    progress.set(1);
+    let render = Arc::new(assets.reload(&root)?);
+    let mut atlas = HudAtlas::build_over(&root, vanilla_root)?;
+    atlas.font.uniform = force_unicode;
+    atlas.font.japanese = japanese;
+    let gui = UiResources {
+        atlas,
+        panorama: Arc::new(horizon_client::gfx::panorama::Faces::load(&root)),
+    };
+    progress.set(2);
+    let pack = PackResources::load(
+        &root,
+        assets.clone(),
+        render,
+        res.facts(),
+        context.biomes.clone(),
+        context.light.clone(),
+    )?;
+    let textures = prepare_renderer_textures(&pack);
+    progress.set(3);
+    Ok(StagedPack {
+        root,
+        gui,
+        pack,
+        textures,
+    })
+}
+
+/// Everything a pack reload builds on the CPU (`apply_staged_pack` finishes
+/// it on the render thread).
+pub(super) struct StagedPack {
+    pub root: PathBuf,
+    pub gui: UiResources,
+    pub pack: PackResources,
+    pub textures: PreparedTextures,
 }
diff --git a/crates/horizon-client/src/game/paintings.rs b/crates/horizon-client/src/game/paintings.rs
index 321e59f7d..d0e984c29 100644
--- a/crates/horizon-client/src/game/paintings.rs
+++ b/crates/horizon-client/src/game/paintings.rs
@@ -267,8 +267,7 @@ impl Game<'_> {
             // measured from the box's centre (HangingEntity's position).
             let (lo, hi) = p.bounds();
             let (lo, hi) = (glam::DVec3::from(lo), glam::DVec3::from(hi));
-            let range =
-                super::entity_culling::default_range(hi - lo, self.settings.entity_distance);
+            let range = super::entity_culling::default_range(hi - lo, self.view_scale());
             if !self.entity_in_view(camera, (lo + hi) / 2.0, range, lo, hi) {
                 continue;
             }
@@ -308,6 +307,8 @@ impl Game<'_> {
                         layer: 0,
                         color,
                         light: packed,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             };
diff --git a/crates/horizon-client/src/game/persist.rs b/crates/horizon-client/src/game/persist.rs
index b5e650e70..8ceea7e12 100644
--- a/crates/horizon-client/src/game/persist.rs
+++ b/crates/horizon-client/src/game/persist.rs
@@ -193,12 +193,12 @@ impl Game<'_> {
                             if let Some(a) = p.arrow.as_mut() {
                                 a.last_state = in_block.and_then(|t| self.state_from_nbt(&t));
                             }
-                            self.creatures.projectiles.push(p);
+                            self.add_projectile(p);
                         }
                     }
                     "minecraft:fireball" | "minecraft:small_fireball" => {
                         if let Some(p) = entity_nbt::fireball_from_nbt(&tag, player_uuid) {
-                            self.creatures.projectiles.push(p);
+                            self.add_projectile(p);
                         }
                     }
                     "minecraft:falling_block" => {
@@ -290,14 +290,22 @@ impl Game<'_> {
                     "minecraft:ender_dragon" => {
                         let seed = self.world.random.next_long();
                         if self.dragon.is_none()
-                            && let Some(d) = super::dragon::Dragon::from_nbt(&tag, seed)
+                            && let Some(mut d) = super::dragon::Dragon::from_nbt(&tag, seed)
                         {
+                            // EnderDragon's constructor takes its id and its
+                            // parts' from the entity counter.
+                            d.id = self.next_entity + 1;
+                            self.next_entity += 9;
                             self.dragon = Some(d);
                         }
                     }
                     "minecraft:end_crystal" => {
                         let time = self.world.random.next_int_bound(100_000).unwrap_or(0);
-                        if let Some(c) = super::dragon::Crystal::from_nbt(&tag, time) {
+                        if let Some(mut c) = super::dragon::Crystal::from_nbt(&tag, time) {
+                            // EndCrystal's constructor takes an id from the
+                            // entity counter.
+                            self.next_entity += 1;
+                            c.id = self.next_entity;
                             self.crystals.push(c);
                         }
                     }
@@ -357,7 +365,8 @@ impl Game<'_> {
     pub(super) fn load_mob(&mut self, tag: Tag, mount: Option<u32>) -> Option<u32> {
         self.next_entity += 1;
         let uuid = entity_nbt::uuid(&tag);
-        // Structure entities placed with finalizeEntities.
+        // Structure mobs that generation left to finish: saves from before
+        // they were finalized at placement, or a placement that could not.
         let mut tag = tag;
         let mut finalize = false;
         if let Tag::Compound(c) = &mut tag {
@@ -449,7 +458,8 @@ impl Game<'_> {
         }
     }
     /// An entity of a type Horizon does not simulate, kept as its compound.
-    fn load_other(&mut self, tag: Tag, kind: &str) -> Option<u32> {
+    fn load_other(&mut self, mut tag: Tag, kind: &str) -> Option<u32> {
+        strip_finalize(&mut tag);
         let position = entity_nbt::position(&tag)?;
         let rotation = match tag.get("Rotation") {
             Some(Tag::List(l)) => {
@@ -531,6 +541,14 @@ impl Game<'_> {
         self.persist.uuids.remove(&id);
         self.persist.raw.remove(&id);
     }
+    /// The compound an entity without a Horizon entity ID was loaded with
+    /// (the crystals and the dragon), found again by type and position.
+    pub(super) fn persist_anon(&self, kind: &str, p: Vec3) -> (Option<[i32; 4]>, Option<&Tag>) {
+        self.persist
+            .anon
+            .get(&anon_key(kind, p))
+            .map_or((None, None), |(_, uuid, raw)| (*uuid, Some(raw)))
+    }
     /// The compound an entity was loaded with (and commands have edited).
     pub(super) fn persist_raw(&self, id: u32) -> Option<&Tag> {
         self.persist.raw.get(&id)
@@ -1014,3 +1032,9 @@ impl Game<'_> {
         self.save.save_entities(chunks)
     }
 }
+/// Only a mob is finalized; another entity drops the request.
+fn strip_finalize(tag: &mut Tag) {
+    if let Tag::Compound(c) = tag {
+        c.remove(&"horizon:finalize".into());
+    }
+}
diff --git a/crates/horizon-client/src/game/perspective.rs b/crates/horizon-client/src/game/perspective.rs
index caf49883b..2c4cd1571 100644
--- a/crates/horizon-client/src/game/perspective.rs
+++ b/crates/horizon-client/src/game/perspective.rs
@@ -218,11 +218,20 @@ impl Game<'_> {
                 _ => None,
             })
         });
-        // A living mount at the default scale and camera distance.
+        // Camera.setup: the living mount's scale and camera distance
+        // attributes (the happy ghast's is 8, the default 4).
         let mount = self
             .riding
             .and_then(|id| self.mobs.iter().find(|m| m.id == id))
-            .map(|_| (1.0, 4.0));
+            .map(|m| {
+                let attribute = |name: &str, default: f64| {
+                    m.kind.attributes.get(name).copied().unwrap_or(default)
+                };
+                (
+                    attribute("minecraft:scale", 1.0) as f32,
+                    attribute("minecraft:camera_distance", 4.0),
+                )
+            });
         // AbstractBoat.positionRider turns a passenger by the boat's
         // deltaRotation after its yRotO was saved, and LocalPlayer.getViewYRot
         // interpolates a passenger's yaw: the boat's turn is spread over the
@@ -443,6 +452,7 @@ impl Game<'_> {
         let packed = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8);
         let atlas = &self.gui.atlas;
         let lookup = |name: &str| atlas.sprites.get(name).map(|r| [r.u0, r.v0, r.u1, r.v1]);
+        let start = out.len();
         horizon_client::mobs::render::render_with(
             m,
             alpha as f32,
@@ -456,6 +466,15 @@ impl Game<'_> {
         self.player_elytra_geometry(m, camera, alpha as f32, packed, out);
         self.spin_attack_geometry(m, camera, alpha as f32, packed, out);
         self.held_item_geometry(m, camera, alpha, packed, true, out);
+        // LivingEntity.isCurrentlyGlowing: the Glowing effect. A server's client is
+        // in its team by its profile name.
+        if self.potions.effects.get("glowing").is_some() {
+            let team = match &self.remote {
+                Some(r) => self.score.board.players_team(&r.profile_name),
+                None => self.player_team(),
+            };
+            self.mark_outline(&out[start..], super::glowing::team_color(team));
+        }
     }
     /// `extractEntityInInventoryFollowsMouse`: the player in the box
     /// `[x0, x1) x [y0, y1)`, `size` pixels per block, turned toward the
@@ -710,6 +729,8 @@ mod preview_tests {
                     color: u32::MAX,
                     light: 0,
                     normal: [0; 4],
+
+                    glint_uv: [0.0, 0.0],
                 })
         };
         // A shield and arm can intersect: neither average depth orders both ends.
diff --git a/crates/horizon-client/src/game/pickups.rs b/crates/horizon-client/src/game/pickups.rs
index 1e19bcfc3..040a6f01b 100644
--- a/crates/horizon-client/src/game/pickups.rs
+++ b/crates/horizon-client/src/game/pickups.rs
@@ -155,6 +155,8 @@ mod tests {
             value: 1,
             age: 0,
             on_ground: false,
+            count: 1,
+            ticks: 0,
         }))
     }
 
diff --git a/crates/horizon-client/src/game/piglins.rs b/crates/horizon-client/src/game/piglins.rs
index bcf9e6ab5..edfd9a3a0 100644
--- a/crates/horizon-client/src/game/piglins.rs
+++ b/crates/horizon-client/src/game/piglins.rs
@@ -4,18 +4,172 @@
 use super::Game;
 use horizon_client::{
     items::ItemStack,
-    mobs::{Species, Who, piglin::ADMIRE},
+    mobs::{
+        Mob, Species, Who,
+        finalize::{
+            SLOT_NAMES, set_drop_chance, set_item, set_slot_enchantments, slot_enchantments,
+            stored_drop_chance,
+        },
+        piglin::{ADMIRE, ATE_RECENTLY},
+    },
 };
 use horizon_core::{geometry::Vec3, random::RandomSource};
 
 impl Game<'_> {
-    fn piglin_loved(&self, item: &str) -> bool {
+    fn item_in_tag(&self, tag: &str, item: &str) -> bool {
         self.res
             .items()
             .item_tags
-            .get("minecraft:piglin_loved")
+            .get(tag)
             .is_some_and(|t| t.contains(item))
     }
+    fn piglin_loved(&self, item: &str) -> bool {
+        self.item_in_tag("minecraft:piglin_loved", item)
+    }
+    /// `PiglinAi.isLovedItem` or a preferred weapon (`Piglin.canReplaceCurrentItem`).
+    fn piglin_wanted(&self, item: &str) -> bool {
+        self.piglin_loved(item) || self.item_in_tag("minecraft:piglin_preferred_weapons", item)
+    }
+    /// The `SLOT_NAMES` index `getEquipmentSlotForItem` picks: armour goes
+    /// to its slot, anything else to the main hand.
+    fn piglin_slot(&self, item: &str) -> usize {
+        let slot = self
+            .res
+            .items()
+            .get(item)
+            .and_then(|i| i.equip_slot.as_deref())
+            .filter(|s| matches!(*s, "head" | "chest" | "legs" | "feet"))
+            .unwrap_or("mainhand");
+        SLOT_NAMES.iter().position(|n| *n == slot).unwrap_or(0)
+    }
+    /// `Piglin.canReplaceCurrentItem`: an empty slot takes anything, a wanted
+    /// item replaces an unwanted one and never the other way round. Vanilla's
+    /// armour and weapon comparison for two equal-interest items is left out
+    /// (the piglin keeps what it has).
+    fn piglin_can_replace(&self, m: &Mob, item: &str, slot: usize) -> bool {
+        let Some(current) = horizon_client::mobs::finalize::item(m, slot) else {
+            return true;
+        };
+        self.piglin_wanted(item) && !self.piglin_wanted(&current)
+    }
+    /// `SimpleContainer.canAddItem` on the piglin's eight slots.
+    fn piglin_can_add(&self, m: &Mob, stack: &ItemStack) -> bool {
+        m.extra.inventory.len() < 8
+            || m.extra.inventory.iter().any(|s| {
+                s.same_item_same_components(stack) && s.count < self.piglin_max_stack(&s.item)
+            })
+    }
+    fn piglin_max_stack(&self, item: &str) -> u32 {
+        self.res.items().get(item).map_or(64, |i| i.max_stack)
+    }
+    /// `PiglinAi.wantsToPickup` (an adult that is not hurt-shy), without
+    /// the baby rule, which babies skip entirely here.
+    fn piglin_wants(&self, m: &Mob, stack: &ItemStack) -> bool {
+        let item = &*stack.item;
+        if self.item_in_tag("minecraft:piglin_repellents", item) {
+            return false;
+        }
+        let holds_loved = m
+            .extra
+            .off_hand
+            .as_deref()
+            .is_some_and(|o| self.piglin_loved(o));
+        if item == "minecraft:gold_ingot" {
+            return !holds_loved;
+        }
+        let space = self.piglin_can_add(m, stack);
+        if item == "minecraft:gold_nugget" {
+            space
+        } else if self.item_in_tag("minecraft:piglin_food", item) {
+            m.extra.ints[0] <= 0 && space
+        } else if !self.piglin_loved(item) {
+            self.piglin_can_replace(m, item, self.piglin_slot(item))
+        } else {
+            !holds_loved && space
+        }
+    }
+    /// `Mob.equipItemIfPossible` for a piglin: put it in its slot when that
+    /// slot takes it (an armour piece that cannot replace what is worn goes
+    /// to an empty main hand), dropping what it replaces by drop chance.
+    fn piglin_equip(&mut self, index: usize, stack: &ItemStack) -> bool {
+        let item = &*stack.item;
+        let mut slot = self.piglin_slot(item);
+        let m = &self.mobs[index];
+        let mut replace = self.piglin_can_replace(m, item, slot);
+        if slot > 1 && !replace {
+            slot = 0;
+            replace = m.extra.main_hand.is_none();
+        }
+        if !replace {
+            return false;
+        }
+        let m = &mut self.mobs[index];
+        let old = horizon_client::mobs::finalize::item(m, slot);
+        let chance = stored_drop_chance(m, slot);
+        let drop_old = old.is_some() && (m.random.next_float() - 0.1).max(0.0) < chance;
+        let old_enchantments = slot_enchantments(m, slot);
+        set_item(m, slot, item);
+        // The piglin keeps what the stack carried (Protection IV stays on).
+        set_slot_enchantments(m, slot, stack.enchantments().to_vec());
+        // setItemSlotAndDropWhenKilled, then persistenceRequired.
+        set_drop_chance(m, slot, 2.0);
+        m.persistent = true;
+        let at = [m.position.x, m.position.y, m.position.z];
+        if let (true, Some(old)) = (drop_old, old) {
+            let mut dropped = ItemStack::new(&old, 1);
+            dropped.set_crafting_enchantments(old_enchantments);
+            self.spawn_item(dropped, at, super::dispenser::new_item_motion(), 10);
+        }
+        true
+    }
+    /// `PiglinAi.putInInventory`: what does not fit is thrown at a random
+    /// spot nearby.
+    fn piglin_stash(&mut self, index: usize, mut stack: ItemStack) {
+        let max = self.piglin_max_stack(&stack.item);
+        let m = &mut self.mobs[index];
+        for s in &mut m.extra.inventory {
+            if stack.count > 0 && s.same_item_same_components(&stack) && s.count < max {
+                let n = (max - s.count).min(stack.count);
+                s.count += n;
+                stack.count -= n;
+            }
+        }
+        while stack.count > 0 && m.extra.inventory.len() < 8 {
+            let n = stack.count.min(max);
+            m.extra.inventory.push(ItemStack {
+                count: n,
+                ..stack.clone()
+            });
+            stack.count -= n;
+        }
+        if stack.count == 0 {
+            return;
+        }
+        let from = [m.position.x, m.position.y + 1.3, m.position.z];
+        let r = &mut self.world.random;
+        let to = [
+            from[0] + f64::from(r.next_float() * 8.0 - 4.0),
+            from[1],
+            from[2] + f64::from(r.next_float() * 8.0 - 4.0),
+        ];
+        self.piglin_throw(from, to, stack);
+    }
+    /// `PiglinAi.stopHoldingOffHandItem` for something that is not
+    /// bartering currency: wear it if it can, else keep it in the inventory.
+    fn piglin_keep(&mut self, index: usize, stack: ItemStack) {
+        // Nuggets keep their whole stack in the inventory (a hand slot here
+        // holds one item id only).
+        if &*stack.item == "minecraft:gold_nugget" || !self.piglin_equip(index, &stack) {
+            self.piglin_stash(index, stack);
+        }
+    }
+    /// `BehaviorUtils.throwItem`: toss a stack from a point toward another.
+    fn piglin_throw(&mut self, from: [f64; 3], to: [f64; 3], stack: ItemStack) {
+        let d = [to[0] - from[0], to[1] - from[1], to[2] - from[2]];
+        let len = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt().max(1e-6);
+        let v = [d[0] / len * 0.3, d[1] / len * 0.3 + 0.1, d[2] / len * 0.3];
+        self.spawn_item(stack, from, v, 40);
+    }
     /// `PiglinAi.isWearingSafeArmor`.
     pub(super) fn wearing_gold(&self) -> bool {
         let tag = self
@@ -28,15 +182,13 @@ impl Game<'_> {
             .flatten()
             .any(|s| tag.is_some_and(|t| t.contains(&*s.item)))
     }
-    /// Piglins notice gold on the ground within 9 blocks, walk to it and
-    /// take it (`GoToWantedItem`, `Piglin.pickUpItem`).
+    /// Piglins notice wanted items on the ground within 9 blocks (`PiglinAi.wantsToPickup`:
+    /// gold and other loved items, nuggets, food, gear), walk to them and
+    /// take them (`GoToWantedItem`, `Piglin.pickUpItem`).
     pub(super) fn piglin_pickups(&mut self) {
         if !self.ui.rules.bool("mob_griefing") {
             return;
         }
-        // Whether each item is piglin-loved, kept until an item is added or
-        // removed (added ones are pushed at the end under a new id).
-        let mut loved: (Option<(usize, Option<u32>)>, Vec<bool>) = (None, Vec::new());
         for i in 0..self.mobs.len() {
             let m = &self.mobs[i];
             if m.species() != Species::Piglin
@@ -44,27 +196,17 @@ impl Game<'_> {
                 || m.is_baby()
                 || m.extra.using_item > 0
                 || m.extra.egg_time > 0
-                || m.extra.off_hand.is_some()
             {
                 continue;
             }
             let pos = m.position;
-            let key = (self.dropped.len(), self.dropped.last().map(|e| e.id));
-            if loved.0 != Some(key) {
-                loved.0 = Some(key);
-                loved.1 = self
-                    .dropped
-                    .iter()
-                    .map(|e| self.piglin_loved(&e.stack.item))
-                    .collect();
-            }
             let best = self
                 .dropped
                 .iter()
                 .enumerate()
-                .filter(|&(j, _)| loved.1[j])
                 .map(|(j, e)| (j, e.position.distance_squared(pos)))
                 .filter(|(_, d)| *d <= 81.0)
+                .filter(|&(j, _)| self.piglin_wants(m, &self.dropped[j].stack))
                 .min_by(|a, b| a.1.total_cmp(&b.1));
             let Some((j, _)) = best else {
                 self.mobs[i].extra.point = None;
@@ -79,24 +221,38 @@ impl Game<'_> {
                 continue;
             }
             // Nuggets come whole, anything else one at a time.
-            let item = e.stack.item.clone();
             let (taken_item, id) = (e.clone(), self.mobs[i].id);
+            let item = e.stack.item.clone();
             self.add_pickup(
                 super::pickups::Taken::Item(Box::new(taken_item)),
                 super::pickups::Collector::Mob(id),
             );
-            let taken = if &*item == "minecraft:gold_nugget" {
-                self.dropped.remove(j).stack.count
+            let stack = if &*item == "minecraft:gold_nugget" {
+                self.dropped.remove(j).stack
             } else {
                 let e = &mut self.dropped[j];
                 e.stack.count -= 1;
+                let one = ItemStack {
+                    count: 1,
+                    ..e.stack.clone()
+                };
                 if e.stack.count == 0 {
                     self.dropped.remove(j);
                 }
-                1
+                one
             };
-            let _ = taken;
-            self.start_admiring(i, item);
+            if self.piglin_loved(&item) {
+                self.start_admiring(i, item);
+            } else if self.item_in_tag("minecraft:piglin_food", &item)
+                && self.mobs[i].extra.ints[0] <= 0
+            {
+                // PiglinAi.eat: the food is gone and it will not eat for a while.
+                self.mobs[i].extra.ints[0] = ATE_RECENTLY;
+                self.mobs[i].nav_stop();
+            } else {
+                self.mobs[i].nav_stop();
+                self.piglin_keep(i, stack);
+            }
         }
     }
     fn start_admiring(&mut self, index: usize, item: std::sync::Arc<str>) {
@@ -109,14 +265,15 @@ impl Game<'_> {
         self.audio
             .play("minecraft:entity.piglin.admiring_item", Some(at), 1.0, 1.0);
     }
-    /// `PiglinAi.mobInteract`: hand a piglin something it loves.
+    /// `PiglinAi.mobInteract`: hand a piglin a gold ingot (only piglin
+    /// currency is accepted from the hand; other loved items are passed over).
     pub(super) fn give_piglin(&mut self, index: usize, item: &str) -> bool {
         let m = &self.mobs[index];
         if m.species() != Species::Piglin
             || m.is_baby()
             || m.extra.using_item > 0
             || m.extra.egg_time > 0
-            || !self.piglin_loved(item)
+            || item != "minecraft:gold_ingot"
         {
             return false;
         }
@@ -124,7 +281,8 @@ impl Game<'_> {
         true
     }
     /// `PiglinAi.stopHoldingOffHandItem` after admiring: gold ingots buy a
-    /// roll of the bartering table, thrown toward the player.
+    /// roll of the bartering table, thrown toward the player; any other loved
+    /// item it picked up is kept (worn if it can be, else stored).
     pub(super) fn finish_admiring(&mut self, mob: u32) {
         let Some(i) = self.mobs.iter().position(|m| m.id == mob) else {
             return;
@@ -132,9 +290,13 @@ impl Game<'_> {
         let Some(item) = self.mobs[i].extra.off_hand.take() else {
             return;
         };
+        if &*item != "minecraft:gold_ingot" {
+            self.piglin_keep(i, ItemStack::new(&item, 1));
+            return;
+        }
         let m = &self.mobs[i];
         let from = [m.position.x, m.position.y + 1.3, m.position.z];
-        let items = if &*item == "minecraft:gold_ingot" && !m.is_baby() {
+        let items = if !m.is_baby() {
             self.res.items().loot_table(
                 "minecraft:gameplay/piglin_bartering",
                 false,
@@ -176,10 +338,7 @@ impl Game<'_> {
                     from[2] + f64::from(r.next_float() * 8.0 - 4.0),
                 ]
             });
-            let d = [to[0] - from[0], to[1] - from[1], to[2] - from[2]];
-            let len = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt().max(1e-6);
-            let v = [d[0] / len * 0.3, d[1] / len * 0.3 + 0.1, d[2] / len * 0.3];
-            self.spawn_item(stack, from, v, 40);
+            self.piglin_throw(from, to, stack);
         }
     }
     /// `PiglinAi.angerNearbyPiglins`.
diff --git a/crates/horizon-client/src/game/piston_push.rs b/crates/horizon-client/src/game/piston_push.rs
new file mode 100644
index 000000000..6bbf1cb39
--- /dev/null
+++ b/crates/horizon-client/src/game/piston_push.rs
@@ -0,0 +1,573 @@
+//! `PistonMovingBlockEntity.moveCollidedEntities` and `moveStuckEntities` for
+//! the entities the game moves itself: the players and the mobs.
+//!
+//! The geometry is in [`horizon_world::piston_push`]; this file supplies the
+//! bodies and applies the movement the way `Entity.move(MoverType.PISTON, …)`
+//! does: limited to 0.51 blocks per tick per axis (`Entity.limitPistonMovement`),
+//! then run through the block collision scan, so a pushed entity stops at a
+//! wall instead of passing through it.
+//!
+use super::Game;
+use horizon_client::collisions::{EntityCollisions, SceneCollisions, with_piston_noclip};
+use horizon_core::geometry::{Aabb, Direction, Vec3, border::BorderGeometry};
+use horizon_core::position::BlockPos;
+use horizon_world::{
+    block_collision_scan::BlockCollisionWorld, level::pistons::MovingPiston,
+    piston_movement::PistonMovement, piston_push, world_movement::EntityMovementWorld,
+};
+
+/// What one piston asks for this tick: where it is, its state, and the progress
+/// `moveCollidedEntities` runs at (before the tick stores it).
+pub(super) type Push = (BlockPos, MovingPiston, f32);
+
+/// Which entity was pushed, so its storage can be reached after the world
+/// borrow ends.
+#[derive(Clone, Copy, Hash, PartialEq, Eq)]
+enum Target {
+    Player,
+    Guest(u32),
+    Mob(usize),
+    Item(usize),
+    Boat(usize),
+    Cart(usize),
+    ArmorStand(usize),
+}
+
+/// `Entity.getStepHeight` of each body, read before the push.
+struct StepHeights {
+    player: f32,
+    guests: std::collections::HashMap<u32, f32>,
+}
+
+/// What the push needs from one entity.
+#[derive(Clone, Copy)]
+struct Body {
+    bounds: Aabb,
+    position: Vec3,
+    on_ground: bool,
+    step_height: f32,
+    /// Standing on the piston's own block (`Entity.isSupportedBy`).
+    supported: bool,
+}
+
+impl Game<'_> {
+    /// Push whatever this tick's moving pistons ran into, in the order the
+    /// pistons ticked: vanilla pushes from each block entity's own tick.
+    pub(super) fn push_piston_entities(&mut self, pushes: Vec<Push>) {
+        let mut accumulators = std::collections::HashMap::new();
+        for push in pushes {
+            self.push_for_piston(push, &mut accumulators);
+        }
+    }
+
+    fn push_for_piston(
+        &mut self,
+        (pos, piston, new_progress): Push,
+        accumulators: &mut std::collections::HashMap<Target, PistonMovement>,
+    ) {
+        let delta_progress = f64::from(new_progress - piston.progress);
+        if delta_progress <= 0.0 {
+            return;
+        }
+        let Some(bindings) = self.collision.pistons() else {
+            return;
+        };
+        let Ok(state) = bindings.collision_related_state(piston.shape_state()) else {
+            return;
+        };
+        let mut scene = SceneCollisions {
+            world: &self.world,
+            binding: self.collision,
+            subject: None,
+        };
+        let Ok(shape) = self
+            .collision
+            .collision_shape(&mut scene, state, [pos.x, pos.y, pos.z])
+        else {
+            return;
+        };
+        if shape.is_empty() {
+            return;
+        }
+        let movement = piston.movement_direction();
+        let boxes: Vec<Aabb> = shape.boxes().to_vec();
+        let facts = self.res.facts();
+        let slime = &*facts.get(piston.moved_state).name == "minecraft:slime_block";
+        let honey = &*facts.get(piston.moved_state).name == "minecraft:honey_block";
+        // `moveStuckEntities` asks the moved state's own top for its box.
+        let sticky_top = if honey {
+            let mut scene = SceneCollisions {
+                world: &self.world,
+                binding: self.collision,
+                subject: None,
+            };
+            self.collision
+                .collision_shape(&mut scene, piston.moved_state, [pos.x, pos.y, pos.z])
+                .ok()
+                .and_then(|s| s.bounds())
+                .map_or(0.0, |b| b.max_position().y)
+        } else {
+            0.0
+        };
+
+        let steps = self.push_step_heights();
+        let search = shape.bounds().map(|bounds| {
+            piston_push::movement_search_area(
+                piston_push::move_by_position_and_progress(pos, bounds, piston.shape_state()),
+                movement,
+                delta_progress,
+            )
+        });
+        let targets = self.push_targets();
+        for &target in &targets {
+            let Some(body) = self.push_body(target, pos, &steps) else {
+                continue;
+            };
+            let amount = piston_push::collided_amount(
+                &boxes,
+                pos,
+                piston.shape_state(),
+                new_progress,
+                movement,
+                body.bounds,
+            );
+            if slime && search.is_some_and(|area| area.intersects(body.bounds)) {
+                self.bounce(target, movement);
+            }
+            if amount > 0.0 {
+                let step = piston_push::step_vector(movement);
+                let before = body.bounds;
+                self.move_pushed(
+                    target,
+                    before,
+                    [body.position.x, body.position.z],
+                    body.step_height,
+                    body.on_ground,
+                    step.scale(amount),
+                    movement,
+                    accumulators,
+                );
+                // `fixEntityWithinPistonBase`: a retracting source piston drags
+                // an entity that is still inside its own block.
+                if !piston.extending
+                    && piston.source
+                    && let Some(after) = self.push_body(target, pos, &steps)
+                    && let Some(fix) = piston_push::fix_within_piston_base(
+                        pos,
+                        after.bounds,
+                        movement,
+                        delta_progress,
+                    )
+                {
+                    let back = piston_push::step_vector(movement.opposite());
+                    self.move_pushed(
+                        target,
+                        after.bounds,
+                        [after.position.x, after.position.z],
+                        after.step_height,
+                        after.on_ground,
+                        back.scale(fix),
+                        movement,
+                        accumulators,
+                    );
+                }
+            }
+        }
+        // Vanilla selects honey passengers after all collided entities have moved.
+        if honey && movement.normal()[1] == 0 {
+            let area = piston_push::sticky_area(pos, piston.shape_state(), sticky_top);
+            for target in targets {
+                let Some(body) = self.push_body(target, pos, &steps) else {
+                    continue;
+                };
+                if piston_push::sticky_entity_selected(
+                    area,
+                    body.bounds,
+                    horizon_world::level::data::PushReaction::PushPull,
+                    body.on_ground,
+                    body.supported,
+                    body.position,
+                ) {
+                    self.move_pushed(
+                        target,
+                        body.bounds,
+                        [body.position.x, body.position.z],
+                        body.step_height,
+                        body.on_ground,
+                        piston_push::step_vector(movement).scale(delta_progress),
+                        movement,
+                        accumulators,
+                    );
+                }
+            }
+        }
+    }
+
+    /// `Entity.getStepHeight` for each body, read once: the attribute lookup
+    /// needs the mutable body, and the push only needs the number.
+    fn push_step_heights(&mut self) -> StepHeights {
+        let player = self
+            .player
+            .as_mut()
+            .and_then(|p| p.attribute("minecraft:step_height").ok())
+            .map_or(0.6, |v| v as f32);
+        let mut guests = std::collections::HashMap::new();
+        if let Some(host) = self.lan.as_mut() {
+            for g in &mut host.hub.guests {
+                let step = g
+                    .motion
+                    .as_mut()
+                    .and_then(|m| m.attribute("minecraft:step_height").ok())
+                    .map_or(0.6, |v| v as f32);
+                guests.insert(g.conn, step);
+            }
+        }
+        StepHeights { player, guests }
+    }
+
+    /// The entities a moving block can run into: the window's player, the LAN
+    /// guests in the level, then the mobs.
+    fn push_targets(&self) -> Vec<Target> {
+        let mut targets = Vec::new();
+        if self.player.is_some() {
+            targets.push(Target::Player);
+        }
+        if let Some(host) = self.lan.as_ref() {
+            targets.extend(
+                host.hub
+                    .guests
+                    .iter()
+                    .filter(|g| host.hub.here(g) && g.loaded && !g.dead)
+                    .map(|g| Target::Guest(g.conn)),
+            );
+        }
+        targets.extend((0..self.mobs.len()).map(Target::Mob));
+        targets.extend((0..self.dropped.len()).map(Target::Item));
+        targets.extend((0..self.boats.len()).map(Target::Boat));
+        targets.extend((0..self.carts.len()).map(Target::Cart));
+        targets.extend((0..self.armor_stands.len()).map(Target::ArmorStand));
+        targets
+    }
+
+    /// What the push needs from one entity, or `None` when it is not pushed:
+    /// removed, dead, a spectator, or an armor-stand marker.
+    fn push_body(&self, target: Target, pos: BlockPos, steps: &StepHeights) -> Option<Body> {
+        let at = [pos.x, pos.y, pos.z];
+        match target {
+            Target::Player => {
+                let p = self.player.as_ref()?;
+                if p.spectator {
+                    return None;
+                }
+                Some(Body {
+                    bounds: p.bounds(),
+                    position: p.position,
+                    on_ground: p.ground.on_ground,
+                    step_height: steps.player,
+                    supported: p.ground.supporting_block == Some(pos),
+                })
+            }
+            Target::Guest(conn) => {
+                let host = self.lan.as_ref()?;
+                let g = host.hub.guests.iter().find(|g| g.conn == conn)?;
+                if g.dead || g.game_mode == 3 {
+                    return None;
+                }
+                let p = g.position;
+                Some(Body {
+                    bounds: Aabb::new(
+                        Vec3::new(p[0] - 0.3, p[1], p[2] - 0.3),
+                        Vec3::new(p[0] + 0.3, p[1] + 1.8, p[2] + 0.3),
+                    ),
+                    position: Vec3::new(p[0], p[1], p[2]),
+                    on_ground: g.on_ground,
+                    step_height: steps.guests.get(&conn).copied().unwrap_or(0.6),
+                    supported: g
+                        .motion
+                        .as_ref()
+                        .is_some_and(|m| m.ground.supporting_block == Some(pos)),
+                })
+            }
+            Target::Mob(i) => {
+                let m = &self.mobs[i];
+                if m.removed || !m.alive() {
+                    return None;
+                }
+                Some(Body {
+                    bounds: m.bounds(),
+                    position: m.position,
+                    on_ground: m.on_ground,
+                    step_height: m.kind.step_height as f32,
+                    supported: m.supporting == Some(at),
+                })
+            }
+            Target::Item(i) => {
+                let entity = &self.dropped[i];
+                Some(Body {
+                    bounds: entity.bounds(),
+                    position: entity.position,
+                    on_ground: entity.on_ground,
+                    step_height: 0.0,
+                    supported: false,
+                })
+            }
+            Target::Boat(i) => {
+                let entity = &self.boats[i];
+                Some(Body {
+                    bounds: entity.bounds(),
+                    position: entity.position,
+                    on_ground: entity.on_ground,
+                    step_height: 0.0,
+                    supported: false,
+                })
+            }
+            Target::Cart(i) => {
+                let entity = &self.carts[i];
+                Some(Body {
+                    bounds: entity.bounds(),
+                    position: entity.position,
+                    on_ground: entity.on_ground,
+                    step_height: 0.0,
+                    supported: false,
+                })
+            }
+            Target::ArmorStand(i) => {
+                let entity = &self.armor_stands[i];
+                if entity.marker {
+                    return None;
+                }
+                Some(Body {
+                    bounds: entity.bounds(),
+                    position: entity.position,
+                    on_ground: entity.on_ground,
+                    step_height: 0.0,
+                    supported: false,
+                })
+            }
+        }
+    }
+
+    /// `Entity.move(MoverType.PISTON, movement)` for one pushed entity: the
+    /// per-tick piston limit, then the block and world border collision scan.
+    fn move_pushed(
+        &mut self,
+        target: Target,
+        before: Aabb,
+        at: [f64; 2],
+        step_height: f32,
+        on_ground: bool,
+        movement: Vec3,
+        piston_direction: Direction,
+        accumulators: &mut std::collections::HashMap<Target, PistonMovement>,
+    ) {
+        let Some(limited) = self.limit_piston(target, movement, accumulators) else {
+            return;
+        };
+        // `limitPistonMovement` returns zero once the tick's budget is spent.
+        if limited == Vec3::ZERO {
+            return;
+        }
+        let resolved = with_piston_noclip(piston_direction, || {
+            pushed_movement(
+                SceneCollisions {
+                    world: &self.world,
+                    binding: self.collision,
+                    subject: None,
+                },
+                self.border.geometry(),
+                at,
+                before,
+                limited,
+                step_height,
+                on_ground,
+            )
+            .unwrap_or(Vec3::ZERO)
+        });
+        if resolved.length_squared() <= 1.0e-7
+            && limited.length_squared() - resolved.length_squared() >= 1.0e-7
+        {
+            return;
+        }
+        self.apply_push(target, resolved);
+    }
+
+    /// `Entity.limitPistonMovement`: each axis may travel at most 0.51 blocks
+    /// per game tick, and a move touches only its first non-zero axis.
+    fn limit_piston(
+        &mut self,
+        target: Target,
+        movement: Vec3,
+        accumulators: &mut std::collections::HashMap<Target, PistonMovement>,
+    ) -> Option<Vec3> {
+        let time = self.world.game_time;
+        let limit = |state: &mut PistonMovement| state.limit(movement, || Ok::<i64, ()>(time)).ok();
+        match target {
+            Target::Player => {
+                let p = self.player.as_mut()?;
+                limit(&mut p.piston)
+            }
+            Target::Guest(conn) => {
+                let host = self.lan.as_mut()?;
+                let g = host.hub.guests.iter_mut().find(|g| g.conn == conn)?;
+                limit(&mut g.motion.as_deref_mut()?.piston)
+            }
+            Target::Mob(i) => limit(&mut self.mobs[i].piston),
+            _ => limit(accumulators.entry(target).or_default()),
+        }
+    }
+
+    fn apply_push(&mut self, target: Target, movement: Vec3) {
+        match target {
+            Target::Player => {
+                if let Some(p) = self.player.as_mut() {
+                    p.position = p.position.add_vector(movement);
+                }
+            }
+            Target::Guest(conn) => {
+                if let Some(host) = self.lan.as_mut()
+                    && let Some(g) = host.hub.guests.iter_mut().find(|g| g.conn == conn)
+                {
+                    // The body and the hub's copy of its position move together:
+                    // `leave_guest` writes the body back over the hub's.
+                    for (slot, delta) in g.position.iter_mut().zip(movement.components()) {
+                        *slot += delta;
+                    }
+                    if let Some(m) = g.motion.as_deref_mut() {
+                        m.position = m.position.add_vector(movement);
+                    }
+                }
+            }
+            Target::Mob(i) => {
+                let m = &mut self.mobs[i];
+                m.position = m.position.add_vector(movement);
+            }
+            Target::Item(i) => {
+                self.dropped[i].position = self.dropped[i].position.add_vector(movement)
+            }
+            Target::Boat(i) => self.boats[i].position = self.boats[i].position.add_vector(movement),
+            Target::Cart(i) => self.carts[i].position = self.carts[i].position.add_vector(movement),
+            Target::ArmorStand(i) => {
+                self.armor_stands[i].position = self.armor_stands[i].position.add_vector(movement)
+            }
+        }
+    }
+
+    /// `causeBounce`: a slime block sets the velocity along the movement axis.
+    fn bounce(&mut self, target: Target, movement: Direction) {
+        match target {
+            Target::Player => {
+                if let Some(p) = self.player.as_mut() {
+                    p.velocity = piston_push::bounce_velocity(movement, p.velocity);
+                }
+            }
+            Target::Mob(i) => {
+                let m = &mut self.mobs[i];
+                m.velocity = piston_push::bounce_velocity(movement, m.velocity);
+            }
+            Target::Guest(conn) => {
+                if let Some(host) = self.lan.as_mut()
+                    && let Some(guest) = host.hub.guests.iter_mut().find(|g| g.conn == conn)
+                    && let Some(motion) = guest.motion.as_deref_mut()
+                {
+                    motion.velocity = piston_push::bounce_velocity(movement, motion.velocity);
+                }
+            }
+            Target::Item(i) => {
+                self.dropped[i].velocity =
+                    piston_push::bounce_velocity(movement, self.dropped[i].velocity)
+            }
+            Target::Boat(i) => {
+                self.boats[i].velocity =
+                    piston_push::bounce_velocity(movement, self.boats[i].velocity)
+            }
+            Target::Cart(i) => {
+                self.carts[i].velocity =
+                    piston_push::bounce_velocity(movement, self.carts[i].velocity)
+            }
+            Target::ArmorStand(i) => {
+                self.armor_stands[i].velocity =
+                    piston_push::bounce_velocity(movement, self.armor_stands[i].velocity)
+            }
+        }
+    }
+}
+
+/// `Entity.move(MoverType.PISTON, movement)` for a pushed body: the movement
+/// it makes. The world's blocks stop it, and so does the world border:
+/// `Entity.collectCollidersIgnoringWorldBorder` adds the border's walls when
+/// the body is inside close to the border, as ordinary movement does.
+fn pushed_movement<W>(
+    blocks: W,
+    border: &BorderGeometry,
+    at: [f64; 2],
+    before: Aabb,
+    movement: Vec3,
+    step_height: f32,
+    on_ground: bool,
+) -> horizon_client::Result<Vec3>
+where
+    W: BlockCollisionWorld<Error = std::io::Error> + EntityMovementWorld<Error = std::io::Error>,
+{
+    EntityCollisions::with_border(blocks, border, at).resolve(
+        before,
+        movement,
+        step_height,
+        on_ground,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use horizon_client::collisions::EmptyCollisions;
+
+    /// A border 10 wide around the origin: its wall's inner face is at x = 5.
+    fn border() -> BorderGeometry {
+        BorderGeometry::new([0.0, 0.0], 10.0, 29_999_984).expect("a border")
+    }
+
+    /// `Entity.collectCollidersIgnoringWorldBorder`: the border's walls stop a
+    /// pushed body that is inside close to the border.
+    #[test]
+    fn a_pushed_body_stops_at_the_world_border() {
+        // A body 0.6 wide, 0.4 blocks short of the wall, pushed east into it.
+        let before = Aabb::new(Vec3::new(4.0, 0.0, 0.0), Vec3::new(4.6, 1.8, 0.6));
+        let border = border();
+        let moved = pushed_movement(
+            EmptyCollisions,
+            &border,
+            [4.3, 0.3],
+            before,
+            Vec3::new(0.51, 0.0, 0.0),
+            0.0,
+            false,
+        )
+        .expect("the push resolves");
+        // The wall stops the body 0.4 blocks short of the whole push.
+        assert!(
+            (moved.x - 0.4).abs() < 1.0e-9,
+            "the body was not stopped by the border: {moved:?}"
+        );
+    }
+
+    /// Away from the border, the same push moves the whole way.
+    #[test]
+    fn a_pushed_body_moves_whole_away_from_the_border() {
+        let before = Aabb::new(Vec3::new(0.0, 0.0, 0.0), Vec3::new(0.6, 1.8, 0.6));
+        let border = border();
+        let moved = pushed_movement(
+            EmptyCollisions,
+            &border,
+            [0.3, 0.3],
+            before,
+            Vec3::new(0.51, 0.0, 0.0),
+            0.0,
+            false,
+        )
+        .expect("the push resolves");
+        assert!(
+            (moved.x - 0.51).abs() < 1.0e-9,
+            "the body did not move the whole push: {moved:?}"
+        );
+    }
+}
diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index 13eae7d3e..c0d7f1e3c 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -2,7 +2,12 @@
 //! `Consumable`), throwing splash/lingering potions (`ThrownSplashPotion`),
 //! filling glass bottles (`BottleItem`), the per-tick effect application,
 //! effect attribute modifiers and the HUD effect icons (`Hud.extractEffects`).
-use super::{Game, Screen, item_draw::owner_at};
+use super::{
+    Game, Screen,
+    dragon::{Breath, FightPlayer, FightWho},
+    item_draw::owner_at,
+    remote_projectiles::cloud_client_tick,
+};
 use horizon_assets::item_model::DisplayContext;
 use horizon_client::{
     block_entity_render::vertex_light,
@@ -12,8 +17,13 @@ use horizon_client::{
     hud_layout, hud_overlays, inventory_effects,
     items::ItemStack,
     mesher::Vertex,
+    particles::{ParticleOptions, ParticleType},
+    text::Text,
+};
+use horizon_core::{
+    geometry::{Aabb, Direction, Vec3},
+    random::{LegacyRandom, RandomSource},
 };
-use horizon_core::{geometry::Vec3, random::RandomSource};
 
 /// A thrown splash or lingering potion in flight.
 #[derive(Clone, Debug)]
@@ -26,9 +36,41 @@ pub(super) struct ThrownPotion {
     position: Vec3,
     velocity: Vec3,
     age: u32,
+    /// `Projectile.getOwner`'s display name: the player who threw it (none
+    /// for a dispenser's).
+    owner: Option<Text>,
+}
+/// `AreaEffectCloud` wait time set by `ThrownLingeringPotion.onHitAsPotion`.
+pub(super) const LINGERING_WAIT: i32 = 10;
+/// `AreaEffectCloud.DEFAULT_REAPPLICATION_DELAY`.
+const REAPPLICATION_DELAY: i32 = 20;
+/// An entity a cloud has affected (`AreaEffectCloud.victims`).
+#[derive(Clone, Copy, PartialEq)]
+enum Victim {
+    Mob(u32),
+    Player(FightWho),
+}
+/// What a lingering potion's `AreaEffectCloud` applies: the potion's effects
+/// (at the lingering item's 0.25 duration scale) and who it has affected.
+pub(super) struct PotionCloud {
+    effects: &'static [(&'static str, i32, i32)],
+    /// The potion's colour (`PotionContents.getColor`).
+    color: u32,
+    /// Each victim and the tick it can be affected again.
+    victims: Vec<(Victim, i32)>,
+    /// Who its instant damage names (`indirectMagic(cloud, owner)`): the
+    /// thrower, else the cloud.
+    source: Text,
+}
+impl PotionCloud {
+    /// `AreaEffectCloud.updateParticle`: an entity effect in the potion's colour.
+    pub(super) fn particle(&self) -> ParticleOptions {
+        let c = |shift: u32| (self.color >> shift & 255) as f32 / 255.0;
+        ParticleOptions::colored(ParticleType::EntityEffect, [c(16), c(8), c(0), 1.0])
+    }
 }
 /// A mob's effect ids carry the `minecraft:` namespace.
-fn mob_effect_id(id: &str) -> Option<&'static str> {
+pub(super) fn mob_effect_id(id: &str) -> Option<&'static str> {
     use std::{collections::HashMap, sync::OnceLock};
     static IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
     let id = id.trim_start_matches("minecraft:");
@@ -44,10 +86,196 @@ fn mob_effect_id(id: &str) -> Option<&'static str> {
     .get(id)
     .copied()
 }
+/// `LivingEntity.canBeAffected` with the mob overrides (`WitherBoss` and
+/// `WitherSkeleton` shrug off wither, `Spider` and `AbstractNautilus` poison,
+/// `Parched` weakness): the immune-to-infested and immune-to-oozing tags
+/// decide first, then the tag of mobs that ignore poison and regeneration.
+fn mob_can_be_affected(
+    tags: &std::collections::HashMap<String, std::collections::HashSet<String>>,
+    kind: &str,
+    effect: &str,
+) -> bool {
+    let effect = effect.trim_start_matches("minecraft:");
+    let kind = kind.trim_start_matches("minecraft:");
+    let overridden = match kind {
+        "wither" | "wither_skeleton" => effect == "wither",
+        "spider" | "cave_spider" | "nautilus" | "zombie_nautilus" => effect == "poison",
+        "parched" => effect == "weakness",
+        _ => false,
+    };
+    if overridden {
+        return false;
+    }
+    let in_tag = |tag: &str| {
+        tags.get(tag)
+            .is_some_and(|t| t.contains(&format!("minecraft:{kind}")))
+    };
+    if in_tag("minecraft:immune_to_infested") {
+        effect != "infested"
+    } else if in_tag("minecraft:immune_to_oozing") {
+        effect != "oozing"
+    } else {
+        !in_tag("minecraft:ignores_poison_and_regen")
+            || (effect != "regeneration" && effect != "poison")
+    }
+}
 impl Game<'_> {
+    /// `LivingEntity.triggerOnDeathMobEffects` (`onMobRemoved` with the reason
+    /// KILLED) for what Oozing, Weaving and Wind Charged do when their bearer
+    /// dies. `bearer` is the dying mob's id, `player` whether it is a player,
+    /// `random` the dying mob's own (`mob.getRandom()`; the world's for the
+    /// player).
+    pub(super) fn effects_on_death(
+        &mut self,
+        effects: &[&str],
+        bounds: Aabb,
+        player: bool,
+        bearer: Option<u32>,
+        mut random: Option<&mut LegacyRandom>,
+    ) {
+        let feet = bounds.bottom_center();
+        if effects.contains(&"oozing") {
+            // OozingMobEffect.numberOfSlimesToSpawn: two, fewer when the
+            // slimes close by already fill the cramming limit.
+            let limit = self.ui.rules.int("max_entity_cramming");
+            let mut count = 2;
+            if limit >= 1 {
+                let near = bounds.inflate(Vec3::new(2.0, 2.0, 2.0));
+                let nearby = self
+                    .mobs
+                    .iter()
+                    .filter(|m| {
+                        m.species() == horizon_client::mobs::Species::Slime
+                            && Some(m.id) != bearer
+                            && m.bounds().intersects(near)
+                    })
+                    .count()
+                    .min(limit as usize) as i32;
+                count = (limit - nearby).clamp(0, count);
+            }
+            for _ in 0..count {
+                // spawnSlimeOffspring: a size 2 slime half a block up.
+                if let Some(id) = self.spawn_mob_for(
+                    "minecraft:slime",
+                    [feet.x, feet.y + 0.5, feet.z],
+                    false,
+                    true,
+                ) && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id)
+                {
+                    horizon_client::mobs::cube::set_size(m, 2);
+                }
+            }
+        }
+        if effects.contains(&"weaving") && (player || self.ui.rules.bool("mob_griefing")) {
+            self.spawn_cobwebs_around(
+                [
+                    feet.x.floor() as i32,
+                    feet.y.floor() as i32,
+                    feet.z.floor() as i32,
+                ],
+                random.as_deref_mut(),
+            );
+        }
+        if effects.contains(&"wind_charged") {
+            // A burst centred at half the height, radius 3 to 5.
+            let center = [feet.x, feet.y + bounds.size().y / 2.0, feet.z];
+            let r = random.unwrap_or(&mut self.world.random);
+            let radius = 3.0 + r.next_float() * 2.0;
+            let _ = self.wind_burst(center, radius, 1.0, false, false);
+        }
+    }
+    /// `WeavingMobEffect.spawnCobwebsRandomlyAround`: two or three cobwebs in
+    /// free spaces with a solid floor, picked among 15 random blocks within one
+    /// block of `pos`.
+    fn spawn_cobwebs_around(&mut self, pos: [i32; 3], mut random: Option<&mut LegacyRandom>) {
+        let r = random.as_deref_mut().unwrap_or(&mut self.world.random);
+        let wanted = 2 + r.next_int_bound(2).unwrap_or(0) as usize;
+        let mut chosen: Vec<[i32; 3]> = Vec::new();
+        for _ in 0..15 {
+            let r = random.as_deref_mut().unwrap_or(&mut self.world.random);
+            let at = [
+                pos[0] - 1 + r.next_int_bound(3).unwrap_or(0),
+                pos[1] - 1 + r.next_int_bound(3).unwrap_or(0),
+                pos[2] - 1 + r.next_int_bound(3).unwrap_or(0),
+            ];
+            let facts = self.res.facts();
+            let here = facts.get(self.world.block(at[0], at[1], at[2]));
+            let below = facts.get(self.world.block(at[0], at[1] - 1, at[2]));
+            if !chosen.contains(&at)
+                && here.replaceable
+                && below.sturdy_full & (1 << Direction::Up as u8) != 0
+            {
+                chosen.push(at);
+                if chosen.len() >= wanted {
+                    break;
+                }
+            }
+        }
+        for at in chosen {
+            if self.set_state_named(at, "minecraft:cobweb", &[]).is_ok() {
+                self.level_event_at(3018, at, 0);
+            }
+        }
+    }
+    /// `InfestedMobEffect.onMobHurt` for the player: from half its height up,
+    /// along where it looks.
+    pub(super) fn player_infested(&mut self) {
+        if let Some(p) = self.player.as_ref() {
+            let at = [
+                p.position.x,
+                p.position.y + f64::from(p.dimensions.height) / 2.0,
+                p.position.z,
+            ];
+            let look = super::view_vector(self.yaw, self.pitch);
+            self.infested_hurt(at, look, None);
+        }
+    }
+    /// A living mob's own random (`Entity.random`), else the world's.
+    fn bearer_random(&mut self, bearer: Option<u32>) -> &mut LegacyRandom {
+        match bearer.and_then(|id| self.mobs.iter().position(|m| m.id == id)) {
+            Some(i) => &mut self.mobs[i].random,
+            None => &mut self.world.random,
+        }
+    }
+    /// `InfestedMobEffect.onMobHurt`: a 10% chance of one or two silverfish at
+    /// `at` (half the bearer's height up), thrown along its look direction.
+    /// The draws are the bearer's (`mob.getRandom()`): `bearer` is the mob,
+    /// none for the player (the world's random).
+    pub(super) fn infested_hurt(&mut self, at: [f64; 3], look: [f64; 3], bearer: Option<u32>) {
+        if self.bearer_random(bearer).next_float() > 0.1 {
+            return;
+        }
+        let count = 1 + self.bearer_random(bearer).next_int_bound(2).unwrap_or(0);
+        for _ in 0..count {
+            // Mth.randomBetween(-PI / 2, PI / 2), then the look direction
+            // scaled by (0.3, 0.45, 0.3) and turned about the y axis.
+            let half = std::f32::consts::FRAC_PI_2;
+            let angle = self.bearer_random(bearer).next_float() * (2.0 * half) - half;
+            let (sin, cos) = angle.sin_cos();
+            let (x, z) = (look[0] * 0.3, look[2] * 0.3);
+            let velocity = Vec3::new(
+                f64::from(x as f32 * cos + z as f32 * sin),
+                look[1] * 0.3 * 1.5,
+                f64::from(-x as f32 * sin + z as f32 * cos),
+            );
+            if let Some(id) = self.spawn_mob_for("minecraft:silverfish", at, false, true)
+                && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id)
+            {
+                m.velocity = velocity;
+            }
+            self.audio
+                .play("minecraft:entity.silverfish.hurt", Some(at), 1.0, 1.0);
+        }
+    }
     /// A splash potion, lingering potion or experience bottle in flight (the
     /// player's throws and dispensers both end up here).
-    pub(super) fn launch_thrown(&mut self, stack: ItemStack, position: Vec3, velocity: Vec3) {
+    pub(super) fn launch_thrown(
+        &mut self,
+        stack: ItemStack,
+        position: Vec3,
+        velocity: Vec3,
+        owner: Option<Text>,
+    ) {
         self.potions.thrown.push(ThrownPotion {
             id: 0,
             stack,
@@ -55,6 +283,7 @@ impl Game<'_> {
             position,
             velocity,
             age: 0,
+            owner,
         });
     }
 }
@@ -135,6 +364,7 @@ impl PotionState {
             position: at,
             velocity,
             age: 0,
+            owner: None,
         });
     }
     /// ThrowableItemProjectile.DATA_ITEM_STACK: the potion it shows.
@@ -237,6 +467,7 @@ impl Game<'_> {
                     },
                     Vec3::new(eye[0], eye[1] - 0.1, eye[2]),
                     v,
+                    Some(self.player_display_text()),
                 );
                 self.swing_arm();
                 self.consume_held();
@@ -276,7 +507,8 @@ impl Game<'_> {
         } else if let Some(rest) = self.give(filled)
             && let Some(eye) = self.eye_position()
         {
-            self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40);
+            // `player.drop(stack, false)`.
+            self.throw_from_eyes(rest, eye, false);
         }
     }
     /// Drinking a potion while right-click is held; true when handled.
@@ -299,6 +531,7 @@ impl Game<'_> {
             return true;
         }
         self.using = None;
+        self.send_use_item_complete();
         self.post_entity_event("minecraft:drink", horizon_client::mobs::Who::Player);
         if ominous {
             self.drink_ominous_bottle(slot, stack);
@@ -376,6 +609,7 @@ impl Game<'_> {
         self.tick_mob_effects();
         if running {
             self.tick_thrown_potions();
+            self.tick_potion_clouds();
         }
     }
     /// `LivingEntity.tickEffects` (server side) for `self.player`, the local
@@ -386,13 +620,37 @@ impl Game<'_> {
             return;
         };
         if player.health.dead_or_dying() {
-            // LivingEntity.die → removeAllEffects.
+            // LivingEntity.die → removeAllEffects. Vanilla runs the effects
+            // that act on death (`onMobRemoved`) when the dead player is
+            // removed, up to 20 ticks later; here it is as the effects go.
+            let w = f64::from(player.dimensions.width) / 2.0;
+            let bounds = Aabb::new(
+                Vec3::new(
+                    player.position.x - w,
+                    player.position.y,
+                    player.position.z - w,
+                ),
+                Vec3::new(
+                    player.position.x + w,
+                    player.position.y + f64::from(player.dimensions.height),
+                    player.position.z + w,
+                ),
+            );
+            let ids: Vec<&'static str> = self.potions.effects.list.iter().map(|e| e.id).collect();
             self.potions.effects.clear();
+            if !ids.is_empty() {
+                self.effects_on_death(&ids, bounds, true, None, None);
+            }
         }
         // The omens act from inside the effect tick (BadOmenMobEffect,
         // RaidOmenMobEffect).
+        let absorption_empty = self
+            .player
+            .as_ref()
+            .is_some_and(|p| p.health.absorption() <= 0.0);
         let mut effects = std::mem::take(&mut self.potions.effects);
-        let (actions, raid_omen_added) = effects.tick_with(&mut |e| self.omen_tick(e));
+        let (actions, raid_omen_added) =
+            effects.tick_with(&mut |e| self.omen_tick(e), absorption_empty);
         self.potions.effects = effects;
         if raid_omen_added {
             self.raid_omen_added();
@@ -400,8 +658,28 @@ impl Game<'_> {
         for action in actions {
             self.apply_effect_action(action);
         }
+        self.turtle_helmet_tick();
         self.apply_effect_status();
     }
+    /// `Player.tick` -> `turtleHelmetTick`: with a turtle helmet on the head
+    /// and the eyes out of the water, Water Breathing for 200 ticks (no
+    /// particles, an icon).
+    fn turtle_helmet_tick(&mut self) {
+        let Some(p) = self.player.as_ref() else {
+            return;
+        };
+        let eye_y = p.position.y + f64::from(p.dimensions.eye_height);
+        if !p.health.dead_or_dying()
+            && self.armor[0]
+                .as_ref()
+                .is_some_and(|s| &*s.item == "minecraft:turtle_helmet")
+            && !self.eye_in_water(p.position.x, eye_y, p.position.z)
+        {
+            let mut effect = EffectInstance::new("water_breathing", 200, 0);
+            effect.visible = false;
+            self.potions.effects.add(effect);
+        }
+    }
     /// A client's own effects (`LivingEntity.tickEffects` on the client,
     /// `MobEffectInstance.tickClient`): they count down, and the server
     /// removes them. Their modifiers and flags move the predicted player.
@@ -513,29 +791,176 @@ impl Game<'_> {
                 let state =
                     self.world
                         .block(p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32);
-                if self.res.facts().get(state).full_collision
-                    || self.mobs.iter().any(|m| {
-                        m.alive()
-                            && (m.position.x - p.x).abs() < m.kind.width / 2.0 + 0.125
-                            && (m.position.z - p.z).abs() < m.kind.width / 2.0 + 0.125
-                            && p.y >= m.position.y
-                            && p.y <= m.position.y + m.kind.height
-                    })
-                {
-                    hit = Some(p);
+                let mob = self.mobs.iter().find(|m| {
+                    m.alive()
+                        && (m.position.x - p.x).abs() < m.kind.width / 2.0 + 0.125
+                        && (m.position.z - p.z).abs() < m.kind.width / 2.0 + 0.125
+                        && p.y >= m.position.y
+                        && p.y <= m.position.y + m.kind.height
+                });
+                if self.res.facts().get(state).full_collision || mob.is_some() {
+                    hit = Some((p, mob.map(|m| m.position)));
                     break;
                 }
             }
-            if let Some(p) = hit {
-                landed.push((t.stack.clone(), p));
+            if let Some((p, mob)) = hit {
+                landed.push((t.stack.clone(), p, mob, t.owner.clone()));
                 return false;
             }
             t.position = next;
             t.age < 1200 && t.position.y > -128.0
         });
         self.potions.thrown = thrown;
-        for (stack, at) in landed {
-            self.splash(&stack, at);
+        for (stack, at, mob, owner) in landed {
+            self.splash(&stack, at, mob, owner);
+        }
+    }
+    /// `AreaEffectCloud.tick` for the lingering potions' clouds: the client
+    /// tick's particles, then the server tick.
+    fn tick_potion_clouds(&mut self) {
+        if self.breath_clouds.iter().all(|c| c.potion.is_none()) {
+            return;
+        }
+        let players: Vec<FightPlayer> = self
+            .fight_players()
+            .into_iter()
+            .filter(|p| p.alive)
+            .collect();
+        let mut clouds = std::mem::take(&mut self.breath_clouds);
+        clouds.retain_mut(|c| c.potion.is_none() || self.tick_potion_cloud(c, &players));
+        self.breath_clouds.append(&mut clouds);
+    }
+    /// `AreaEffectCloud.serverTick` for a lingering potion's cloud: after its
+    /// wait it shrinks, and every 5 ticks it affects the living entities in
+    /// its box and radius that were not affected in the last 20 ticks, each
+    /// taking some of its radius. False once it is gone.
+    fn tick_potion_cloud(&mut self, c: &mut Breath, players: &[FightPlayer]) -> bool {
+        c.age += 1;
+        let Some(potion) = c.potion.as_mut() else {
+            return true;
+        };
+        if c.age - LINGERING_WAIT >= c.duration {
+            return false;
+        }
+        let waiting = c.age < LINGERING_WAIT;
+        cloud_client_tick(
+            &mut self.particles,
+            c.at,
+            c.radius,
+            waiting,
+            &potion.particle(),
+        );
+        if waiting {
+            return true;
+        }
+        // setRadiusPerTick(-radius / duration).
+        c.radius += -3.0 / 600.0;
+        if c.radius < 0.5 {
+            return false;
+        }
+        if c.age % 5 != 0 {
+            return true;
+        }
+        potion.victims.retain(|(_, until)| c.age < *until);
+        let r = f64::from(c.radius);
+        let area = Aabb::new(
+            Vec3::new(c.at[0] - r, c.at[1], c.at[2] - r),
+            Vec3::new(c.at[0] + r, c.at[1] + 0.5, c.at[2] + r),
+        );
+        let mut inside = Vec::new();
+        for p in players.iter().filter(|p| p.bounds.intersects(area)) {
+            inside.push((Victim::Player(p.who), p.position.x, p.position.z));
+        }
+        let effects = potion.effects;
+        let tags = &self.res.stations().enchantments.entity_tags;
+        // Only mobs that at least one of the cloud's effects can affect are
+        // taken (`allEffects.stream().anyMatch(entity::canBeAffected)`), so
+        // the others neither become victims nor use up its radius.
+        for m in self.mobs.iter().filter(|m| {
+            m.alive()
+                && m.bounds().intersects(area)
+                && effects
+                    .iter()
+                    .any(|(id, ..)| mob_can_be_affected(tags, &m.kind.id, id))
+        }) {
+            inside.push((Victim::Mob(m.id), m.position.x, m.position.z));
+        }
+        for (victim, x, z) in inside {
+            let (dx, dz) = (x - c.at[0], z - c.at[2]);
+            if potion.victims.iter().any(|(v, _)| *v == victim)
+                || dx * dx + dz * dz > f64::from(c.radius * c.radius)
+            {
+                continue;
+            }
+            potion.victims.push((victim, c.age + REAPPLICATION_DELAY));
+            self.cloud_affect(victim, effects, c.at, &potion.source);
+            // setRadiusOnUse(-0.5).
+            c.radius -= 0.5;
+            if c.radius < 0.5 {
+                return false;
+            }
+        }
+        true
+    }
+    /// What a cloud puts on one entity: instant effects at half strength
+    /// (`applyInstantaneousEffect` with 0.5), the others for their duration
+    /// at the lingering item's 0.25 scale (`PotionContents.forEachEffect`).
+    fn cloud_affect(
+        &mut self,
+        victim: Victim,
+        effects: &'static [(&'static str, i32, i32)],
+        at: [f64; 3],
+        source: &Text,
+    ) {
+        let scaled = |duration: i32| ((f64::from(duration) * 0.25) as i32).max(1);
+        match victim {
+            Victim::Player(who) => self.as_fight_player(who, |g| {
+                for (id, duration, amp) in effects {
+                    let Some(e) = brewing::effect(id) else {
+                        continue;
+                    };
+                    if e.instant {
+                        if let Some(a) = horizon_client::effects::instant(id, *amp, 0.5) {
+                            g.apply_indirect_effect_action(a, source);
+                        }
+                    } else {
+                        g.add_player_effect(EffectInstance::new(e.id, scaled(*duration), *amp));
+                    }
+                }
+            }),
+            Victim::Mob(mob) => {
+                let Some(i) = self.mobs.iter().position(|m| m.id == mob) else {
+                    return;
+                };
+                // Undead invert healing and harming.
+                let tags = &self.res.stations().enchantments.entity_tags;
+                let inverted = tags
+                    .get("minecraft:inverted_healing_and_harm")
+                    .is_some_and(|t| t.contains(&self.mobs[i].kind.id));
+                for (id, duration, amp) in effects {
+                    let m = &mut self.mobs[i];
+                    match *id {
+                        "instant_damage" | "instant_health" => {
+                            let amount =
+                                |base: i32| (0.5 * f64::from(base << amp) + 0.5) as i32 as f32;
+                            if (*id == "instant_damage") != inverted {
+                                m.hurt(amount(6), Some(at), &mut self.world.random);
+                            } else {
+                                m.health = (m.health + amount(4)).min(m.kind.max_health);
+                            }
+                        }
+                        _ => {
+                            // `LivingEntity.addEffect` refuses what the mob
+                            // cannot be affected by.
+                            if mob_can_be_affected(tags, &m.kind.id, id)
+                                && let Some(name) = mob_effect_id(id)
+                            {
+                                m.add_effect(name, scaled(*duration), *amp);
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
     /// `ThrowableProjectile.tick`'s `applyGravity` and `applyInertia`, which
@@ -637,12 +1062,24 @@ impl Game<'_> {
             self.submit_item_world(&state, pose, vertex_light(light), out);
         }
     }
+    /// `HealOrHarmMobEffect.applyInstantaneousEffect` with a source (a
+    /// potion or a cloud): indirectMagic, not plain magic.
+    fn apply_indirect_effect_action(&mut self, a: EffectAction, source: &Text) {
+        let a = match a {
+            EffectAction::Hurt("minecraft:magic", amount) => {
+                self.note_direct_entity("minecraft:indirect_magic", source.clone());
+                EffectAction::Hurt("minecraft:indirect_magic", amount)
+            }
+            a => a,
+        };
+        self.apply_effect_action(a);
+    }
     /// A splash potion's effects on the player in place, by their distance.
     fn splash_on_player(
         &mut self,
         effects: &'static [(&'static str, i32, i32)],
         at: Vec3,
-        scale: f64,
+        source: &Text,
     ) {
         if let Some(p) = self.player.as_ref() {
             let center = Vec3::new(
@@ -658,10 +1095,10 @@ impl Game<'_> {
                     let instant = brewing::effect(id).is_some_and(|e| e.instant);
                     if instant {
                         if let Some(a) = horizon_client::effects::instant(id, *amp, intensity) {
-                            self.apply_effect_action(a);
+                            self.apply_indirect_effect_action(a, source);
                         }
                     } else {
-                        let d = (intensity * f64::from(*duration) * scale + 0.5) as i32;
+                        let d = (intensity * f64::from(*duration) + 0.5) as i32;
                         if d > 20
                             && let Some(e) = brewing::effect(id)
                         {
@@ -672,69 +1109,67 @@ impl Game<'_> {
             }
         }
     }
-    /// `ThrownSplashPotion.onHitAsPotion` (lingering clouds apply as a weaker splash).
-    fn splash(&mut self, stack: &ItemStack, at: Vec3) {
+    /// `ThrownSplashPotion.onHitAsPotion`, or `ThrownLingeringPotion.onHitAsPotion`
+    /// for a lingering potion; `mob` is where it hit a mob.
+    fn splash(&mut self, stack: &ItemStack, at: Vec3, mob: Option<Vec3>, owner: Option<Text>) {
+        let block = [at.x, at.y, at.z].map(|v| v.floor() as i32);
         if &*stack.item == "minecraft:experience_bottle" {
             // ThrownExperienceBottle.onHit: the water-coloured splash (level
-            // event 2002) and 3 to 11 experience.
-            let pitch = self.world.random.next_float() * 0.1 + 0.9;
-            self.audio.play(
-                "minecraft:entity.splash_potion.break",
-                Some([at.x, at.y, at.z]),
-                1.0,
-                pitch,
-            );
-            for _ in 0..8 {
-                let v = [
-                    f64::from(self.world.random.next_float() - 0.5) * 0.3,
-                    0.2,
-                    f64::from(self.world.random.next_float() - 0.5) * 0.3,
-                ];
-                let p = horizon_client::particles::Particle::terrain(
-                    &mut self.world.random,
-                    [at.x, at.y, at.z],
-                    v,
-                    "item/splash_potion".into(),
-                    0x38_5DC6,
-                );
-                self.particles.push(p);
-            }
+            // event 2002, its sound 1053) and 3 to 11 experience.
+            self.level_event_at(2002, block, 0xFF38_5DC6u32 as i32);
+            self.level_event_at(1053, block, 0);
             let r = &mut self.world.random;
             let value = 3 + r.next_int_bound(5).unwrap_or(0) + r.next_int_bound(5).unwrap_or(0);
             self.spawn_orbs([at.x, at.y, at.z], value as u32);
             return;
         }
         let lingering = &*stack.item == "minecraft:lingering_potion";
-        let event = if lingering {
-            "minecraft:entity.lingering_potion.break"
-        } else {
-            "minecraft:entity.splash_potion.break"
-        };
-        let pitch = self.world.random.next_float() * 0.1 + 0.9;
-        self.audio.play(event, Some([at.x, at.y, at.z]), 1.0, pitch);
+        // AbstractThrownPotion.onHit: level event 2007 and sound 1054 for a
+        // potion with instant effects, 2002 and 1053 otherwise.
+        let potion = stack.potion().and_then(brewing::potion);
+        let instant = potion.is_some_and(|d| {
+            d.effects
+                .iter()
+                .any(|(id, ..)| brewing::effect(id).is_some_and(|e| e.instant))
+        });
         let color = brewing::potion_color(stack.potion());
-        for _ in 0..8 {
-            let v = [
-                f64::from(self.world.random.next_float() - 0.5) * 0.3,
-                0.2,
-                f64::from(self.world.random.next_float() - 0.5) * 0.3,
-            ];
-            let p = horizon_client::particles::Particle::terrain(
-                &mut self.world.random,
-                [at.x, at.y, at.z],
-                v,
-                "item/splash_potion".into(),
-                color,
-            );
-            self.particles.push(p);
-        }
-        let scale = if lingering { 0.25 } else { 1.0 };
-        let Some(def) = stack.potion().and_then(brewing::potion) else {
+        self.level_event_at(if instant { 2007 } else { 2002 }, block, color as i32);
+        self.level_event_at(if instant { 1054 } else { 1053 }, block, 0);
+        let Some(def) = potion else {
             return;
         };
+        if lingering {
+            // The cloud sits at the mob it hit (its feet), else the impact;
+            // radius 3, wait 10, 600 ticks, shrinking to nothing, and a
+            // potion with no effects leaves none.
+            if !def.effects.is_empty() {
+                let at = mob.unwrap_or(at);
+                self.breath_clouds.push(Breath {
+                    id: 0,
+                    at: [at.x, at.y, at.z],
+                    radius: 3.0,
+                    age: 0,
+                    duration: 600,
+                    from_dragon: false,
+                    potion: Some(PotionCloud {
+                        effects: def.effects,
+                        color,
+                        victims: Vec::new(),
+                        source: owner.unwrap_or_else(|| {
+                            Text::translate("entity.minecraft.area_effect_cloud", &[])
+                        }),
+                    }),
+                });
+            }
+            return;
+        }
         // Every player in range (`ThrownSplashPotion.applySplash` over
         // `LivingEntity`s, the players among them).
-        self.for_each_player(|g| g.splash_on_player(def.effects, at, scale));
+        // Instant damage is indirectMagic(potion, owner), which the death
+        // message names by the owner, else by the potion.
+        let source =
+            owner.unwrap_or_else(|| Text::translate("entity.minecraft.splash_potion", &[]));
+        self.for_each_player(|g| g.splash_on_player(def.effects, at, &source));
         // Mobs take the instant effects (undead invert healing and harming).
         let undead = &self.res.stations().enchantments.entity_tags;
         let mut hits = Vec::new();
@@ -757,7 +1192,7 @@ impl Game<'_> {
                     _ => {
                         // `Potion.applySplash`: timed effects last in
                         // proportion to how close the mob was.
-                        let d = (intensity * f64::from(*duration) * scale + 0.5) as i32;
+                        let d = (intensity * f64::from(*duration) + 0.5) as i32;
                         if d > 20
                             && let Some(name) = mob_effect_id(id)
                         {
diff --git a/crates/horizon-client/src/game/powder_snow.rs b/crates/horizon-client/src/game/powder_snow.rs
index 6a904706f..7d935d07b 100644
--- a/crates/horizon-client/src/game/powder_snow.rs
+++ b/crates/horizon-client/src/game/powder_snow.rs
@@ -53,7 +53,11 @@ impl Game<'_> {
         if let Some(player) = self.player.as_mut() {
             player.fire_ticks = 0;
         }
-        // Entity.playEntityOnFireExtinguishedSound
+        self.extinguish_sound(at);
+        Ok(())
+    }
+    /// Entity.playEntityOnFireExtinguishedSound
+    fn extinguish_sound(&mut self, at: [f64; 3]) {
         let r = self.particles.random();
         let pitch = 1.6 + (r.next_float() - r.next_float()) * 0.4;
         self.audio.play(
@@ -62,7 +66,29 @@ impl Game<'_> {
             0.7,
             pitch,
         );
-        Ok(())
+    }
+    /// `Entity.applyEffectsFromBlocks`: a burning player in the rain
+    /// (`isInRain`) has the fire put out (`clearFire`), with the extinguish
+    /// sound that everyone near hears.
+    pub(super) fn rain_extinguish_player(&mut self) {
+        let Some(player) = self.player.as_ref() else {
+            return;
+        };
+        let (at, top) = (player.position, player.bounds().max_position().y);
+        if player.fire_ticks <= 0 || !self.in_rain(at, top) {
+            return;
+        }
+        if let Some(player) = self.player.as_mut() {
+            player.fire_ticks = 0;
+        }
+        self.extinguish_sound([at.x, at.y, at.z]);
+    }
+    /// The in-window player's rain extinguish (a server's player has its
+    /// fire put out by the server).
+    pub(super) fn rain_extinguish_in_frame(&mut self) {
+        if self.remote.is_none() {
+            self.rain_extinguish_player();
+        }
     }
     /// Whether the block at `pos` is powder snow.
     pub(super) fn is_powder_snow(&self, pos: [i32; 3]) -> bool {
diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs
index bedca5708..8fbcfc6dd 100644
--- a/crates/horizon-client/src/game/raids.rs
+++ b/crates/horizon-client/src/game/raids.rs
@@ -235,7 +235,7 @@ impl Game<'_> {
         }
         out
     }
-    fn difficulty_id(&self) -> i32 {
+    pub(super) fn difficulty_id(&self) -> i32 {
         use horizon_world::food::Difficulty;
         match self.world.health_rules.difficulty {
             Difficulty::Peaceful => 0,
@@ -762,7 +762,7 @@ impl Game<'_> {
             }
             positions.push((m.id, m.position, s.active_raid));
         }
-        let banners: Vec<(usize, Vec3)> = self
+        let banners: Vec<(usize, u32, Vec3)> = self
             .dropped
             .iter()
             .enumerate()
@@ -771,7 +771,7 @@ impl Game<'_> {
                     && e.stack.data().is_some_and(|d| d.ominous_banner)
                     && e.pickup_delay == 0
             })
-            .map(|(i, e)| (i, e.position))
+            .map(|(i, e)| (i, e.id, e.position))
             .collect();
         let mut taken: Vec<usize> = Vec::new();
         let mut collectors: Vec<(usize, u32)> = Vec::new();
@@ -796,6 +796,8 @@ impl Game<'_> {
             let s = m.extra.raider.get_or_insert_with(Box::default);
             s.rider = has_rider;
             s.in_village = in_village;
+            // Vindicator.customServerAiStep: `ServerLevel.isRaided`.
+            s.raided = species == Species::Vindicator && raids.nearby(block).is_some();
             if s.raid_id.is_some_and(|id| raids.get(id).is_none()) {
                 s.raid_id = None;
                 s.ticks_outside_raid = 0;
@@ -856,20 +858,33 @@ impl Game<'_> {
                 && raids.get(id).is_some_and(|r| r.leader(s.wave).is_none())
                 && !leaders.contains(&(id, s.wave))
             {
+                let in_reach = |(i, _, p): &&(usize, u32, Vec3)| {
+                    !taken.contains(i)
+                        && (p.x - position.x).abs() <= range
+                        && (p.z - position.z).abs() <= range
+                        && (p.y - position.y).abs() <= 8.0
+                };
+                let by_distance = |a: &&(usize, u32, Vec3), b: &&(usize, u32, Vec3)| {
+                    a.2.distance_squared(position)
+                        .total_cmp(&b.2.distance_squared(position))
+                };
+                // The unreachable cache only picks the navigation target;
+                // a banner next to the raider is still picked up.
                 let near = banners
                     .iter()
-                    .filter(|(i, p)| {
-                        !taken.contains(i)
-                            && (p.x - position.x).abs() <= range
-                            && (p.z - position.z).abs() <= range
-                            && (p.y - position.y).abs() <= 8.0
+                    .filter(in_reach)
+                    .filter(|(_, item, _)| {
+                        !s.unreachable_banners
+                            .iter()
+                            .any(|&(b, until)| b == *item && now < until)
                     })
-                    .min_by(|a, b| {
-                        a.1.distance_squared(position)
-                            .total_cmp(&b.1.distance_squared(position))
-                    });
-                if let Some((i, p)) = near {
+                    .min_by(by_distance);
+                let nearest = banners.iter().filter(in_reach).min_by(by_distance);
+                let adjacent =
+                    nearest.filter(|(_, _, p)| p.distance_squared(position) < 1.414 * 1.414);
+                if let Some((i, item, p)) = adjacent.or(near) {
                     s.banner_at = Some([p.x, p.y, p.z]);
+                    s.banner_item = *item;
                     if p.distance_squared(position) < 1.414 * 1.414 {
                         // pickUpItem: the banner becomes the wave's leader.
                         taken.push(*i);
@@ -1034,6 +1049,7 @@ impl Game<'_> {
     /// read it).
     fn sync_villager_raids(&mut self, infos: &HashMap<i32, Vec<RaiderInfo>>) {
         let raids = &self.raiding.raids;
+        let mut ongoing = Vec::new();
         for m in &mut self.mobs {
             if m.species() != Species::Villager {
                 continue;
@@ -1059,7 +1075,27 @@ impl Game<'_> {
             let ext = mobs_villager::ext_mut(m);
             ext.raid = status;
             ext.raid_wave = wave;
+            if !m.no_ai && matches!(status, mobs_villager::PRE_RAID | mobs_villager::RAID) {
+                ongoing.push(m.id);
+            }
         }
+        // Villager.customServerAiStep: a 1 in 100 chance each tick, in an
+        // ongoing raid, of entity event 42 (`handleEntityEvent` splashes).
+        for id in ongoing {
+            if self.particles.random().next_int_bound(100) == Ok(0) {
+                self.mob_raid_splash(id);
+            }
+        }
+    }
+    /// Entity event 42 for villager `id`: the guests get the byte, and this
+    /// game draws `AbstractVillager.addParticlesAroundSelf(SPLASH)` itself.
+    fn mob_raid_splash(&mut self, id: u32) {
+        let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
+            return;
+        };
+        let at = [m.position.x, m.position.y, m.position.z];
+        self.lan_entity_event(id as i32, 42, at);
+        self.particles_around_mob(id, "splash", horizon_client::particles::Burst::VILLAGER);
     }
 
     /// The raid bar a living player at `at` is in (`Raid.getPlayers`): red,
diff --git a/crates/horizon-client/src/game/recipe_book.rs b/crates/horizon-client/src/game/recipe_book.rs
index 96e12d79b..9991ce366 100644
--- a/crates/horizon-client/src/game/recipe_book.rs
+++ b/crates/horizon-client/src/game/recipe_book.rs
@@ -338,6 +338,25 @@ impl Game<'_> {
         ui.client_known = Some(known.clone());
         ui.client_version += 1;
     }
+    /// Every entry of the book, in its order (capability `recipes`).
+    #[cfg(feature = "mods")]
+    pub(super) fn recipe_book_entries(&mut self) -> Vec<Entry> {
+        self.ensure_book();
+        self.recipe_ui
+            .book
+            .as_ref()
+            .map_or_else(Vec::new, |b| b.entries.clone())
+    }
+    /// The display ids the player's book holds, and a number that changes
+    /// whenever they do (capability `recipes`).
+    #[cfg(feature = "mods")]
+    pub(super) fn recipe_book_displays(&mut self) -> (u64, Vec<i32>) {
+        self.sync_client_book();
+        (
+            self.recipe_ui.client_version,
+            self.recipe_ui.client.displays(),
+        )
+    }
     fn ensure_book(&mut self) {
         if self.recipe_ui.book.is_none() {
             let mut book = Book::build(self.res.recipes(), self.res.items());
@@ -590,6 +609,7 @@ impl Game<'_> {
         if inside(cursor, bx, by, 20.0, 18.0) {
             let open = !self.book_open(book_type);
             self.level.recipe_book.open[book_type.index()] = open;
+            self.send_book_settings(book_type);
             if !open {
                 self.recipe_ui.overlay = None;
             }
@@ -675,6 +695,7 @@ impl Game<'_> {
         if inside(cursor, xo + 110.0, yo + 12.0, 26.0, 16.0) {
             let filtering = !self.book_filtering(book_type);
             self.level.recipe_book.filtering[book_type.index()] = filtering;
+            self.send_book_settings(book_type);
             self.recipe_ui.page = 0;
             self.audio
                 .play("minecraft:ui.button.click", None, 0.25, 1.0);
@@ -695,6 +716,22 @@ impl Game<'_> {
         }
         false
     }
+    /// `RecipeBookComponent.sendUpdateSettings`: the server owns the saved book.
+    fn send_book_settings(&self, book_type: BookType) {
+        self.send(
+            horizon_protocol::packets::play::Serverbound::RecipeBookChangeSettings(
+                horizon_protocol::packets::recipes::RecipeBookChangeSettings {
+                    book_type: book_type.index() as i32,
+                    open: self.book_open(book_type),
+                    filtering: self.book_filtering(book_type),
+                },
+            ),
+        );
+    }
+    pub(super) fn recipe_book_flags(&self) -> Option<(bool, bool)> {
+        let book = self.active_book()?;
+        Some((self.book_open(book), self.book_filtering(book)))
+    }
     /// How many displays the client's book holds.
     pub(super) fn recipe_book_known(&self) -> usize {
         self.recipe_ui.client.displays().len()
@@ -826,6 +863,34 @@ impl Game<'_> {
         self.recipe_ui.ghost.clear();
         self.place_recipe(book_type, entry_index, use_max);
     }
+    /// Whether the open screen takes `recipes.place`: a crafting grid's
+    /// book (the inventory's or a crafting table's).
+    #[cfg(feature = "mods")]
+    pub(super) fn mod_recipe_screen(&self) -> bool {
+        self.screen == Screen::Inventory
+            && self.active_book() == Some(BookType::Crafting)
+            && !self.spectator()
+    }
+    /// `recipes.place`: the book's click on the recipe with this display
+    /// id, refused as `handlePlaceRecipe` refuses it (no crafting screen,
+    /// not in the player's book; an impossible one in `place_recipe`).
+    #[cfg(feature = "mods")]
+    pub(super) fn mod_place_recipe(&mut self, display_id: i32, all: bool) {
+        if !self.mod_recipe_screen() || !self.recipe_ui.client.displays().contains(&display_id) {
+            return;
+        }
+        self.ensure_book();
+        let Some(index) = self
+            .recipe_ui
+            .book
+            .as_ref()
+            .and_then(|b| b.entries.iter().position(|e| e.display_id == display_id))
+        else {
+            return;
+        };
+        self.recipe_ui.ghost.clear();
+        self.place_recipe(BookType::Crafting, index, all);
+    }
     /// `ServerboundPlaceRecipePacket`: the server places the recipe
     /// (`ServerPlaceRecipe` on the menu engine) and answers with a ghost
     /// recipe when the items are missing.
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 6b0d2477d..31615ee9b 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -117,13 +117,17 @@ pub(super) struct Remote {
     joined: bool,
     status: String,
     pub(super) entity_id: i32,
+    /// The item the player's use began with (`LivingEntity.useItem`).
+    pub(super) use_item: Option<Arc<str>>,
     dimension: DimensionType,
     /// What chunk packets decode with (the dimension's height and sky, the
     /// biome registry); replaced whenever one of them changes.
     pub(super) chunk_format: Arc<ChunkFormat>,
     /// Decodes chunk packets as they arrive, off the frame.
     decoder: ChunkDecoder,
-    view_distance: i32,
+    /// Options.serverRenderDistance: the server's view distance from the
+    /// login or the last chunk-cache-radius packet.
+    pub(super) view_distance: i32,
     sequence: i32,
     position_sender: horizon_client::player_sync::PositionSender,
     last_input: u8,
@@ -182,6 +186,9 @@ pub(super) struct Remote {
     online_mode: bool,
     /// Player entities in the level: entity id to profile UUID.
     level_players: HashMap<i32, u128>,
+    /// Entities with shared flag 6 (`Entity.isCurrentlyGlowing` on a client); mobs keep
+    /// theirs in `Mob::glowing`.
+    glowing: std::collections::HashSet<i32>,
     /// The local player's profile UUID (always in the level).
     profile: u128,
     /// The local player's profile name: its score holder and team member.
@@ -189,9 +196,15 @@ pub(super) struct Remote {
     destroying: Option<([i32; 3], u8, f32)>,
     destroy_delay: u32,
     input: horizon_client::interaction_input::InteractionInput,
+    /// Keys whose presses send a packet (swap hands, drop, a mount's
+    /// inventory): like the click queue, they wait for the tick's
+    /// `handleKeybinds` phase rather than going out between window events.
+    pub(super) pending_keys: Vec<KeyCode>,
     stop_mining: bool,
     placing: Option<([i32; 3], u64)>,
     death_message: Option<String>,
+    /// `LocalPlayer.showDeathScreen`: off with `immediate_respawn`.
+    show_death_screen: bool,
     player_type: Option<Arc<MobType>>,
     /// Inventory as last synchronised, for creative-mode slot updates.
     synced: Vec<Option<ItemStack>>,
@@ -212,6 +225,9 @@ pub(super) struct Remote {
     /// `ClientboundTransferPacket`'s target: when the connection ends the
     /// game connects here, the stored cookies carried over (`TransferState`).
     transfer: Option<String>,
+    /// `ClientCommonPacketListenerImpl.serverLinks`: the links "Server
+    /// Links..." in the pause menu lists (only `http`/`https` URIs kept).
+    pub(super) server_links: Vec<horizon_protocol::packets::configuration::ServerLink>,
 }
 
 /// The time a frame spends on chunk packets before it leaves the rest of
@@ -394,6 +410,9 @@ impl Game<'_> {
         self.carried = None;
         self.using = None;
         self.clicks.miss_time = 0;
+        // A new LocalPlayer has no effects: the server sends what it has
+        // (ClientboundUpdateMobEffectPacket on placement).
+        self.potions = Default::default();
         self.set_mode_id(0);
         self.experience = Experience {
             level: 0,
@@ -428,6 +447,7 @@ impl Game<'_> {
             joined: false,
             status: "Connecting to the server...".into(),
             entity_id: 0,
+            use_item: None,
             dimension: DimensionType::vanilla("minecraft:overworld"),
             chunk_format: Arc::new(ChunkFormat::new(
                 &DimensionType::vanilla("minecraft:overworld"),
@@ -468,14 +488,17 @@ impl Game<'_> {
             listed: Default::default(),
             online_mode: false,
             level_players: HashMap::new(),
+            glowing: Default::default(),
             profile: 0,
             profile_name: String::new(),
             destroying: None,
             destroy_delay: 0,
             input: Default::default(),
+            pending_keys: Vec::new(),
             stop_mining: false,
             placing: None,
             death_message: None,
+            show_death_screen: true,
             player_type,
             synced: vec![None; 36],
             decode_errors: 0,
@@ -486,6 +509,7 @@ impl Game<'_> {
             chunk_center: (0, 0),
             backlog: VecDeque::new(),
             backlog_since: None,
+            server_links: Vec::new(),
             transfer: None,
         });
         // The level's TickRateManager follows the server's ticking packets.
@@ -862,6 +886,11 @@ impl Game<'_> {
                 }
                 Event::PackPush(p) => self.handle_pack_push(p),
                 Event::PackPop(id) => self.handle_pack_pop(id),
+                Event::ServerLinks(links) => {
+                    if let Some(r) = self.remote.as_mut() {
+                        r.server_links = super::server_links::trusted(links);
+                    }
+                }
                 Event::ShowDialog(dialog) => self.show_dialog(&dialog),
                 Event::ClearDialog => self.clear_dialog(),
                 Event::DecodeError(e) => {
@@ -1283,6 +1312,8 @@ impl Game<'_> {
                 value: 1,
                 age: 0,
                 on_ground: false,
+                count: 1,
+                ticks: 0,
             });
         }
         if let Some(t) = mob_type {
@@ -1417,6 +1448,13 @@ impl Game<'_> {
                 }
                 return;
             }
+            // So does a firework rocket: its own tick flies it on.
+            if path.is_some()
+                && let Some(f) = self.rockets.iter_mut().find(|f| f.id == id as u32)
+            {
+                f.position = Vec3::new(position[0], position[1], position[2]);
+                return;
+            }
             // A dragon fireball keeps Entity's NO_OP InterpolationHandler too:
             // the server's position replaces its own at once.
             if let Some(b) = self.dragon_fireballs.iter_mut().find(|b| b.id == id as u32) {
@@ -1475,7 +1513,9 @@ impl Game<'_> {
         self.remove_remote_dragon(id);
         self.remove_remote_object(id as u32);
         self.remove_remote_projectile(id as u32);
+        self.persist.uuids.remove(&(id as u32));
         if let Some(r) = self.remote.as_mut() {
+            r.glowing.remove(&id);
             r.entities.remove(&id);
             r.lerps.remove(&id);
             r.stepped.remove(&id);
@@ -1569,7 +1609,7 @@ impl Game<'_> {
         }
     }
     /// Find a game slot in the menu's complete, contiguous slot mapping.
-    fn menu_slot_index(menu: &str, internal: usize) -> Option<usize> {
+    pub(super) fn menu_slot_index(menu: &str, internal: usize) -> Option<usize> {
         (0..)
             .map_while(|slot| Self::menu_slot(menu, slot))
             .position(|slot| slot == internal)
@@ -1630,10 +1670,15 @@ impl Game<'_> {
             }
             C::Login(p) => {
                 self.level.hardcore = p.hardcore;
+                // handleLogin makes a new MultiPlayerGameMode (carried index 0) and a
+                // new LocalPlayer (slot 0).
+                self.selected = 0;
                 if let Some(r) = self.remote.as_mut() {
+                    r.carried = Some(0);
                     r.online_mode = p.online_mode;
                     r.entity_id = p.player_id;
                     r.view_distance = p.chunk_radius;
+                    r.show_death_screen = p.show_death_screen;
                 }
                 self.streaming.radius =
                     self.settings.render_distance.min(p.chunk_radius + 1).max(2);
@@ -1648,8 +1693,10 @@ impl Game<'_> {
                 self.send(S::ClientInformation(info));
             }
             C::Respawn(p) => {
-                // A new player, without effects: the server sends them again.
+                // A new player, without effects (the server sends them
+                // again) and with no item in use.
                 self.potions.effects.clear();
+                self.using = None;
                 self.enter_remote_dimension(&p.spawn, true);
                 self.screen = Screen::Playing;
                 if let Some(r) = self.remote.as_mut() {
@@ -1750,7 +1797,17 @@ impl Game<'_> {
                         f64::from(p.y) / 8.0,
                         f64::from(p.z) / 8.0,
                     ];
-                    self.audio.play(&name, Some(at), p.volume, p.pitch);
+                    // ClientPacketListener.handleSoundEvent plays with packet.getSource().
+                    match usize::try_from(p.source)
+                        .ok()
+                        .filter(|s| *s < horizon_client::settings::SOUND_SOURCES.len())
+                    {
+                        Some(source) => {
+                            self.audio
+                                .play_on(source, &name, Some(at), p.volume, p.pitch)
+                        }
+                        None => self.audio.play(&name, Some(at), p.volume, p.pitch),
+                    }
                 }
             }
             C::StopSound(p) => self
@@ -1776,6 +1833,11 @@ impl Game<'_> {
                         r.level_players.remove(&p.id);
                     }
                 }
+                // Entity.getTeam: a mob is on a team by its UUID.
+                self.persist.uuids.insert(
+                    p.id as u32,
+                    horizon_client::lan::playerdata::uuid_ints(p.uuid),
+                );
                 self.spawn_entity(p.id, &kind, p.position, rotation);
                 // Entity.recreateFromPacket: setDeltaMovement(packet.getMovement()).
                 self.remote_motion(p.id, p.velocity);
@@ -1867,7 +1929,8 @@ impl Game<'_> {
             }
             C::SetPassengers(p) => self.remote_set_passengers(p.vehicle, &p.passengers),
             // ClientPacketListener.handleEntityLinkPacket: who holds a mob's
-            // lead (this player, another player or a mob), for the rope.
+            // lead (this player, another player, a mob or a fence knot), for
+            // the rope.
             C::SetEntityLink(p) => {
                 let me = self.remote.as_ref().map(|r| r.entity_id);
                 if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.source as u32) {
@@ -1875,7 +1938,12 @@ impl Game<'_> {
                     m.extra.leash = match p.dest {
                         0 => None,
                         d if Some(d) == me => Some(Holder::Player),
-                        d => Some(Holder::Mob(d as u32)),
+                        d => match self.remote_knots.get(&(d as u32)) {
+                            Some(&block) => Some(Holder::Knot(block)),
+                            // Not a known knot yet: kept by id until the knot
+                            // arrives (game/remote_objects.rs).
+                            None => Some(Holder::Mob(d as u32)),
+                        },
                     };
                 }
             }
@@ -1894,7 +1962,10 @@ impl Game<'_> {
                 if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
                     for (index, _, value) in &p.values {
                         match (index, value) {
-                            (0, Value::Byte(flags)) => m.invisible = flags & 0x20 != 0,
+                            (0, Value::Byte(flags)) => {
+                                m.invisible = flags & 0x20 != 0;
+                                m.glowing = flags & 0x40 != 0;
+                            }
                             (2, Value::OptText(name)) => {
                                 let text = name.as_ref().map(horizon_client::entity_nbt::name_text);
                                 m.custom_name =
@@ -1911,6 +1982,15 @@ impl Game<'_> {
                         }
                     }
                 }
+                if let Some((_, _, Value::Byte(flags))) = p.values.iter().find(|v| v.0 == 0)
+                    && let Some(r) = self.remote.as_mut()
+                {
+                    if flags & 0x40 != 0 {
+                        r.glowing.insert(p.id);
+                    } else {
+                        r.glowing.remove(&p.id);
+                    }
+                }
                 self.remote_mob_data(p.id, &p.values);
                 if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32)
                     && m.species() == horizon_client::mobs::Species::Creeper
@@ -1925,6 +2005,22 @@ impl Game<'_> {
                         }
                     }
                 }
+                if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
+                    for (index, _, value) in &p.values {
+                        match (index, value) {
+                            // Entity.DATA_TICKS_FROZEN: isFullyFrozen shakes it.
+                            (7, Value::Int(ticks)) => m.ticks_frozen = *ticks,
+                            // Strider.DATA_SUFFOCATING (after AgeableMob's two
+                            // and DATA_BOOST_TIME): a cold strider shakes.
+                            (19, Value::Bool(cold))
+                                if m.species() == horizon_client::mobs::Species::Strider =>
+                            {
+                                m.extra.flag = *cold;
+                            }
+                            _ => {}
+                        }
+                    }
+                }
                 // LivingEntity.DATA_LIVING_ENTITY_FLAGS: for another player
                 // too, remote_mob_data's apply reads index 8 above.
                 let mannequin = self
@@ -1984,9 +2080,9 @@ impl Game<'_> {
                         }
                     }
                 }
-                // Entity.DATA_SHARED_FLAGS_ID's crouching bit: another
-                // player's or a mannequin's crouch (their model and
-                // Entity.isDiscrete's name tag).
+                // Entity.DATA_SHARED_FLAGS_ID's crouching and sprinting bits:
+                // another player's or a mannequin's crouch (their model and
+                // Entity.isDiscrete's name tag), and the dust a runner raises.
                 if (mannequin
                     || self
                         .remote
@@ -1997,6 +2093,7 @@ impl Game<'_> {
                     for (index, _, value) in &p.values {
                         if let (0, Value::Byte(flags)) = (index, value) {
                             m.extra.crouching = flags & 2 != 0;
+                            m.extra.sprinting = flags & 8 != 0;
                         }
                     }
                 }
@@ -2022,13 +2119,22 @@ impl Game<'_> {
             // player holds and wears (EquipmentSlot ordinals).
             C::SetEquipment(p) => {
                 self.remote_object_equipment(p.id, &p.slots);
-                let items: Vec<(u8, Option<Arc<str>>)> = p
+                let items: Vec<(u8, Option<Arc<str>>, Option<ItemStack>)> = p
                     .slots
                     .iter()
-                    .map(|(slot, stack)| (*slot, stack.as_ref().map(|s| self.item_name(s.item))))
+                    .map(|(slot, stack)| {
+                        (
+                            *slot,
+                            stack.as_ref().map(|s| self.item_name(s.item)),
+                            self.to_stack(stack),
+                        )
+                    })
                     .collect();
                 if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
-                    for (slot, item) in items {
+                    // The body slot (6: horse armour, llama carpet, harness)
+                    // is kept in `head`, as Horizon's own mobs do.
+                    let body = horizon_client::mobs::drops::head_is_body(m.species());
+                    for (slot, item, stack) in items {
                         let e = &mut m.extra;
                         match slot {
                             0 => e.main_hand = item,
@@ -2036,7 +2142,9 @@ impl Game<'_> {
                             2 => e.feet = item,
                             3 => e.legs = item,
                             4 => e.chest = item,
-                            5 => e.head = item,
+                            5 if !body => e.head = item,
+                            6 if body => e.head = item,
+                            7 => m.set_saddle(stack),
                             _ => {}
                         }
                     }
@@ -2075,7 +2183,10 @@ impl Game<'_> {
                 {
                     self.add_pickup(super::pickups::Taken::Orb(Box::new(orb)), collector);
                 }
-                self.remove_entity(p.item);
+                // An orb stays: the server may still hold merged ones in it.
+                if !orb {
+                    self.remove_entity(p.item);
+                }
             }
             // ClientPacketListener.handleSetEntityMotion: knockback on this player.
             C::SetEntityMotion(p) if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) => {
@@ -2104,8 +2215,9 @@ impl Game<'_> {
             }
             C::HurtAnimation(p) => {
                 if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) {
+                    // Player.animateHurt: the tilt turns around the yaw.
                     if let Some(pl) = self.player.as_mut() {
-                        pl.health.animate_hurt();
+                        pl.health.animate_hurt_dir(p.yaw);
                     }
                 } else if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
                     m.hurt_time = 10;
@@ -2117,6 +2229,7 @@ impl Game<'_> {
                 if p.event == super::fireworks::FIREWORK_EXPLODE_EVENT {
                     self.remote_firework_explosion(p.id);
                 }
+                self.remote_fangs_event(p.id as u32, p.event);
                 // LocalPlayer.setPermissions also refreshes an open World Options screen.
                 if (24..=28).contains(&p.event)
                     && self.remote.as_ref().is_some_and(|r| r.entity_id == p.id)
@@ -2141,9 +2254,76 @@ impl Game<'_> {
                 {
                     m.health = 0.0;
                 }
+                // The events that start a mob's animation (the warden's).
+                if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
+                    horizon_client::mobs::sync::entity_event(m, p.event as u8);
+                }
+                // LivingEntity.handleEntityEvent 60: the poof as the dead body goes.
+                if p.event == 60
+                    && let Some(m) = self.mobs.iter().find(|m| m.id == p.id as u32)
+                {
+                    let (at, w, h) = (m.position, f64::from(m.width()), f64::from(m.height()));
+                    self.death_poof([at.x, at.y, at.z], w, h);
+                }
                 if p.event == super::totem::TOTEM_EVENT {
                     self.remote_totem(p.id);
                 }
+                // Mob.handleEntityEvent 20: the spawn poof.
+                if p.event == 20 && self.mobs.iter().any(|m| m.id == p.id as u32) {
+                    self.poof_particles(p.id as u32);
+                }
+                // Villager 12, 13 and 14, TamableAnimal and AbstractHorse 6 and
+                // 7, Animal and Allay 18: the particles about the mob.
+                if matches!(p.event, 6 | 7 | 12 | 13 | 14 | 18) {
+                    self.entity_event_particles(p.id as u32, p.event);
+                }
+                // Snowball and ThrownEgg.handleEntityEvent 3: the crumbs where
+                // the projectile is (the server removes it right after).
+                if p.event == 3 {
+                    let crumbs = self
+                        .creatures
+                        .projectiles
+                        .iter()
+                        .find(|pr| pr.id == p.id as u32)
+                        .and_then(|pr| {
+                            let item = match pr.kind {
+                                horizon_client::projectiles::ProjectileKind::Snowball => {
+                                    "minecraft:snowball"
+                                }
+                                horizon_client::projectiles::ProjectileKind::Egg => "minecraft:egg",
+                                _ => return None,
+                            };
+                            Some(([pr.position.x, pr.position.y, pr.position.z], item))
+                        });
+                    if let Some((at, item)) = crumbs {
+                        self.item_burst(at, item);
+                    }
+                }
+                if p.event == super::combat::DROWN_EVENT {
+                    self.remote_drown(p.id);
+                }
+                // Entity event 53: the honey slide particles of a player
+                // sliding down a honey block (HoneyBlock.showSlideParticles).
+                if p.event == 53 {
+                    let at = if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) {
+                        self.player
+                            .as_ref()
+                            .map(|q| [q.position.x, q.position.y, q.position.z])
+                    } else {
+                        self.mobs
+                            .iter()
+                            .find(|m| m.id == p.id as u32)
+                            .map(|m| [m.position.x, m.position.y, m.position.z])
+                    };
+                    if let Some(at) = at {
+                        self.honey_slide_particles(at);
+                    }
+                }
+                if p.event == super::consume::USE_ITEM_COMPLETE_EVENT
+                    && self.remote.as_ref().is_some_and(|r| r.entity_id == p.id)
+                {
+                    self.remote_complete_using();
+                }
             }
             C::Animate(p) => self.remote_animate(p.id, p.action),
             // ClientPacketListener.handleSwingAnimation: the entity swings
@@ -2193,7 +2373,11 @@ impl Game<'_> {
                     pl.health.flash_health_change(p.health);
                 }
                 self.apply_remote_health();
-                if p.health <= 0.0 && self.screen != Screen::Dead && self.player.is_some() {
+                // The death screen opens (or the respawn is asked for) with the
+                // death packet when the rule hides it.
+                let shown = self.remote.as_ref().is_none_or(|r| r.show_death_screen);
+                if p.health <= 0.0 && shown && self.screen != Screen::Dead && self.player.is_some()
+                {
                     self.screen = Screen::Dead;
                     self.ui.death_time = 0;
                     self.capture(false);
@@ -2209,11 +2393,16 @@ impl Game<'_> {
                     r.death_message = Some(message);
                 }
                 // ClientPacketListener.handlePlayerCombatKill: the death
-                // screen, whatever health was last sent.
+                // screen, whatever health was last sent, or `respawn()` at
+                // once when it is hidden.
                 if me && self.screen != Screen::Dead && self.player.is_some() {
-                    self.screen = Screen::Dead;
-                    self.ui.death_time = 0;
-                    self.capture(false);
+                    if self.remote.as_ref().is_none_or(|r| r.show_death_screen) {
+                        self.screen = Screen::Dead;
+                        self.ui.death_time = 0;
+                        self.capture(false);
+                    } else {
+                        self.respawn_player()?;
+                    }
                 }
             }
             C::TrackedWaypoint(p) => self.handle_waypoint(&p),
@@ -2289,6 +2478,12 @@ impl Game<'_> {
                         r.game_mode = mode;
                     }
                 }
+                // IMMEDIATE_RESPAWN: LocalPlayer.setShowDeathScreen.
+                11 => {
+                    if let Some(r) = self.remote.as_mut() {
+                        r.show_death_screen = p.param == 0.0;
+                    }
+                }
                 7 => {
                     self.world.weather.rain_level = (p.param, p.param);
                     self.world.weather.raining = p.param > 0.0;
@@ -2306,10 +2501,11 @@ impl Game<'_> {
                 }
                 self.apply_remote_abilities();
             }
+            // ClientPacketListener.handleSetHeldSlot: a hotbar slot only, and the
+            // carried index stays, so the next tick answers with SetCarriedItem.
             C::SetHeldSlot(p) => {
-                self.selected = p.slot.clamp(0, 8) as usize;
-                if let Some(r) = self.remote.as_mut() {
-                    r.carried = Some(self.selected);
+                if (0..9).contains(&p.slot) {
+                    self.selected = p.slot as usize;
                 }
             }
             C::ContainerSetContent(p) => {
@@ -2805,7 +3001,7 @@ impl Game<'_> {
                 resolved.push((uuid, skin));
             }
         }
-        resolved.retain(|(_, skin)| !skin.starts_with("skins/") || self.show_skin(skin));
+        resolved.retain(|(_, skin)| !skin.starts_with("skins/") || self.again_skin(skin));
         let Some((level, skins, own)) = self.remote.as_mut().map(|r| {
             r.skins = resolved.into_iter().collect();
             (
@@ -2844,11 +3040,9 @@ impl Game<'_> {
             .iter()
             .filter(|m| &*m.kind.id == "minecraft:mannequin" && m.profile.is_some())
             .map(|m| {
-                let t = m
-                    .profile
-                    .as_ref()
-                    .and_then(|p| p.properties.iter().find(|p| p.name == "textures"));
-                let textures = t.map_or_else(Default::default, |t| {
+                let profile = m.profile.as_ref();
+                let t = profile.and_then(|p| p.properties.iter().find(|p| p.name == "textures"));
+                let textures = if let Some(t) = t {
                     let signature = if t.signature.is_some() {
                         horizon_client::skins::Signature::Signed
                     } else {
@@ -2859,7 +3053,30 @@ impl Game<'_> {
                         signature,
                         &horizon_client::skins::TEXTURE_URIS,
                     )
-                });
+                } else {
+                    // `ResolvableProfile.resolveProfile`: no `textures` and
+                    // only a name or an id resolves through the services.
+                    let key = profile.and_then(|p| match (&p.name, p.uuid) {
+                        (Some(name), None) => {
+                            Some(horizon_client::skins::NameOrId::Name(name.clone()))
+                        }
+                        (None, Some(id)) => Some(horizon_client::skins::NameOrId::Id(id)),
+                        _ => None,
+                    });
+                    key.and_then(|key| match self.skin_profiles.borrow_mut().state(&key) {
+                        horizon_client::skins::Resolve::Done(Some(profile)) => {
+                            profile.textures().map(|(value, signature)| {
+                                horizon_client::skins::unpack(
+                                    &value,
+                                    signature,
+                                    &horizon_client::skins::TEXTURE_URIS,
+                                )
+                            })
+                        }
+                        _ => None,
+                    })
+                    .unwrap_or_default()
+                };
                 (m.id, textures)
             })
             .collect();
@@ -2874,7 +3091,7 @@ impl Game<'_> {
             resolved.push((id, skin));
         }
         for (id, skin) in resolved {
-            let skin = skin.filter(|s| !s.starts_with("skins/") || self.show_skin(s));
+            let skin = skin.filter(|s| !s.starts_with("skins/") || self.again_skin(s));
             if let Some(mob) = self
                 .mobs
                 .iter_mut()
@@ -2924,6 +3141,10 @@ impl Game<'_> {
         self.skin_slots.push(e);
         true
     }
+    /// `show_skin`, or — its slot evicted — the image queued for upload again.
+    fn again_skin(&mut self, location: &str) -> bool {
+        self.show_skin(location) || self.skin_downloads.borrow_mut().again(location)
+    }
     /// ChatType decoration: `chat.translation_key` with sender/content parameters.
     /// ChatType.Bound.decorate: the chat type's translation, with the
     /// sender, the target and the message as its parameters, in its style.
@@ -3029,6 +3250,8 @@ impl Game<'_> {
             b.velocity = v;
         } else if let Some(t) = self.tridents.iter_mut().find(|t| t.id == id as u32) {
             t.velocity = v;
+        } else if let Some(r) = self.rockets.iter_mut().find(|r| r.id == id as u32) {
+            r.velocity = v;
         } else if let Some(p) = self
             .remote
             .as_mut()
@@ -3142,13 +3365,18 @@ impl Game<'_> {
 
     fn tick_remote_level(&mut self) -> Result<()> {
         self.ticks += 1;
+        // AbstractSignEditScreen.tick: the editor closes once its sign is removed.
+        if let Some(edit) = &self.sign_edit
+            && !matches!(
+                self.world.block_entities.get(&edit.pos),
+                Some(BlockEntity::Sign(_))
+            )
+        {
+            self.close_sign_editor();
+        }
         self.track_experience_display();
-        // Player.tick's ItemCooldowns.tick: this path replaces `tick_world`'s
-        // for a server's client (multiplayer and the default single player),
-        // so the entries advance here or the slot stays shaded until the
-        // server says the entry ended. `onCooldownEnded` is the plain
-        // ItemCooldowns' no-op on a client.
-        self.cooldowns.tick();
+        // Leaving a slot clears its bundle's selection here and on the server.
+        self.tick_bundle_hover();
         // Options.broadcastOptions: a changed render distance or Chat option
         // is sent again.
         let view = client_view_distance(self.settings.render_distance);
@@ -3182,6 +3410,14 @@ impl Game<'_> {
         // Window callbacks only queue clicks, so an interaction cannot leak
         // between CLIENT_TICK_END and a later pong.
         self.remote_handle_input();
+        // Player.tick's ItemCooldowns.tick, in ClientLevel.tickEntities after
+        // handleKeybinds: this path replaces `tick_world`'s for a server's
+        // client (multiplayer and the default single player), so the entries
+        // advance here or the slot stays shaded until the server says the
+        // entry ended. `onCooldownEnded` is the plain ItemCooldowns' no-op on
+        // a client. Ticking it after the keybinds keeps a held use from
+        // trying again a tick before the server's entry ends.
+        self.cooldowns.tick();
         // ClientLevel.tick: the border's size change.
         self.border.tick();
         self.player_border();
@@ -3193,6 +3429,8 @@ impl Game<'_> {
         self.with_level(|b, level, ticks| {
             b.client_tick_block_entities(level, ticks);
         });
+        let pushes = std::mem::take(&mut self.block_ticks.piston_pushes);
+        self.push_piston_entities(pushes);
         self.sync_moving_pistons();
         self.tick_hand();
         self.tick_particles();
@@ -3303,6 +3541,11 @@ impl Game<'_> {
                 resources: self.motion,
             }
             .controlled_simulation_tick(keys)?;
+        } else {
+            // LivingEntity.baseTick counts hurtTime down for a dead or riding
+            // player too (controlled_simulation_tick does it otherwise): left
+            // at 10, the hurt tilt restarted every frame and shook the camera.
+            player.health.advance_clock();
         }
         // LocalPlayer.onUpdateAbilities: flight turned on or off (a double
         // jump, a spectator, landing) is sent to the server.
@@ -3313,13 +3556,12 @@ impl Game<'_> {
         let events = std::mem::take(&mut player.events);
         self.previous_eye = self.eye;
         self.eye += (player.dimensions.eye_height - self.eye) * 0.5;
-        let crouching = player.pose == horizon_client::pose::Pose::Crouching;
         let feet = [player.position.x, player.position.y, player.position.z];
         for event in events {
             match event {
                 horizon_client::motion::MotionEvent::Emission {
                     state, in_water, ..
-                } if !crouching => {
+                } => {
                     let sounds = self.res.facts().get(state).sounds.clone();
                     // Player.playStepSound: muffled under the swim sound in water.
                     let (volume, pitch) = if in_water {
@@ -3333,12 +3575,27 @@ impl Game<'_> {
                     self.audio
                         .play("minecraft:entity.player.swim", Some(feet), volume, pitch);
                 }
+                horizon_client::motion::MotionEvent::Chime { volume, pitch } => {
+                    self.audio.play(
+                        "minecraft:block.amethyst_block.chime",
+                        Some(feet),
+                        volume,
+                        pitch,
+                    );
+                }
                 // NetherPortalBlock.entityInside on the client's own level:
                 // the portal overlay and its trigger sound (the server moves
                 // the player).
                 horizon_client::motion::MotionEvent::InsidePortal { .. } => {
                     self.client_inside_nether_portal();
                 }
+                // HoneyBlock.maybeDoSlideEffects on the client's own level:
+                // the slide sound, heard here (LocalPlayer.playSound); the
+                // particles come from the server's event 53.
+                horizon_client::motion::MotionEvent::HoneySlide { sound: true, .. } => {
+                    self.audio
+                        .play("minecraft:block.honey_block.slide", Some(feet), 1.0, 1.0);
+                }
                 _ => {}
             }
         }
@@ -3492,6 +3749,7 @@ impl Game<'_> {
                 m.fluids = fluids;
             }
         }
+        let game_time = self.world.game_time;
         let Some(r) = self.remote.as_mut() else {
             return;
         };
@@ -3500,11 +3758,15 @@ impl Game<'_> {
         let head_lerps = &mut r.head_lerps;
         let players = &r.level_players;
         let mut using = Vec::new();
+        let mut wither_heads = Vec::new();
         for m in &mut self.mobs {
             let player = players.contains_key(&(m.id as i32));
             if !running && !player {
                 continue;
             }
+            if m.species() == horizon_client::mobs::Species::Wither {
+                wither_heads.extend((0..3).map(|i| horizon_client::mobs::wither::head_pos(m, i)));
+            }
             m.previous = m.position;
             m.previous_yaw = m.yaw;
             m.previous_body_yaw = m.body_yaw;
@@ -3515,6 +3777,16 @@ impl Game<'_> {
             if m.species() == horizon_client::mobs::Species::Rabbit {
                 horizon_client::mobs::rabbit::base_tick(m);
             }
+            if matches!(
+                m.species(),
+                horizon_client::mobs::Species::Horse
+                    | horizon_client::mobs::Species::Donkey
+                    | horizon_client::mobs::Species::Mule
+                    | horizon_client::mobs::Species::SkeletonHorse
+                    | horizon_client::mobs::Species::ZombieHorse
+            ) {
+                horizon_client::mobs::equine::tail_tick(m);
+            }
             if m.species() == horizon_client::mobs::Species::Creeper {
                 horizon_client::mobs::hostile::creeper_client_tick(m);
             }
@@ -3525,6 +3797,10 @@ impl Game<'_> {
             ) {
                 horizon_client::mobs::guardian::client_tick(m);
             }
+            // PolarBear.tick: the stand animation follows the synched flag.
+            if m.species() == horizon_client::mobs::Species::PolarBear {
+                horizon_client::mobs::polar_bear::client_tick(m);
+            }
             if m.hurt_time > 0 {
                 m.hurt_time -= 1;
             }
@@ -3563,7 +3839,7 @@ impl Game<'_> {
                         m.extra.main_hand.clone()
                     };
                     if let Some(item) = item {
-                        let eye = if m.extra.crouching { 1.27 } else { 1.62 };
+                        let eye = m.eye_height();
                         let at = [m.position.x, m.position.y, m.position.z];
                         using.push((
                             item,
@@ -3597,6 +3873,8 @@ impl Game<'_> {
             if m.species() == horizon_client::mobs::Species::Bat {
                 horizon_client::mobs::bat::setup_animation_states(m);
             }
+            // The animation states a server computes in its own `ai_step`.
+            horizon_client::mobs::sync::client_tick(m, game_time);
         }
         for o in self.orbs.iter_mut().filter(|_| running) {
             o.previous = o.position;
@@ -3621,10 +3899,24 @@ impl Game<'_> {
             d.tick(world, facts, collision, false, &self.res.motion().fluids);
         }
         head_lerps.retain(|_, (_, steps)| *steps > 0);
+        // WitherBoss.aiStep runs on a client too: smoke around each head.
+        let smoke = horizon_client::particles::ParticleOptions::simple(
+            horizon_client::particles::ParticleType::Smoke,
+        );
+        for h in wither_heads {
+            let r = self.particles.random();
+            let at = [
+                h[0] + r.next_gaussian() * 0.3,
+                h[1] + r.next_gaussian() * 0.3,
+                h[2] + r.next_gaussian() * 0.3,
+            ];
+            self.particles.add(&smoke, at, [0.0; 3]);
+        }
         for (item, ticks, at, eye, pitch, yaw) in using {
             self.remote_player_eating(&item, ticks, at, eye, pitch, yaw);
         }
         if running {
+            self.guardian_bubbles();
             // The dragon: LivingEntity's interpolation, inside its aiStep.
             let dragon_lerp = self
                 .dragon
@@ -3879,6 +4171,9 @@ impl Game<'_> {
             if let Some(r) = self.remote.as_mut() {
                 r.destroying = Some((hit.pos, face, 0.0));
             }
+            // startDestroyBlock plays the first hit and crack itself; the
+            // server's level events 2019 and 2020 do the rest.
+            self.breaking_block_effects(hit.pos, hit.face, true);
             self.mining = Some(Mining {
                 pos: hit.pos,
                 progress: 0.0,
@@ -3891,20 +4186,6 @@ impl Game<'_> {
         };
         let done = done + progress;
         let ticks = self.mining.as_ref().map_or(0, |m| m.ticks) + 1;
-        if ticks % 4 == 1 {
-            let c = [
-                f64::from(pos[0]) + 0.5,
-                f64::from(pos[1]) + 0.5,
-                f64::from(pos[2]) + 0.5,
-            ];
-            self.audio.play(
-                &facts.sounds.hit,
-                Some(c),
-                (facts.sounds.volume + 1.0) / 8.0,
-                facts.sounds.pitch * 0.5,
-            );
-        }
-        self.crack_particle(pos, hit.face, state);
         if done >= 1.0 {
             let seq = self.next_sequence();
             self.predict_break(pos, state, seq);
@@ -4064,18 +4345,15 @@ impl Game<'_> {
                 world_border: false,
                 sequence: seq,
             }));
-            let target = [
-                hit.pos[0] + hit.face[0],
-                hit.pos[1] + hit.face[1],
-                hit.pos[2] + hit.face[2],
-            ];
-            let ticks = self.ticks;
+            // Only a predicted placement (predict_place) marks a cell whose
+            // resend plays a place sound: an empty hand or a non-block item
+            // places nothing (BlockItem.place is where the sound comes from).
             if let Some(r) = self.remote.as_mut() {
                 r.use_target = Some(hit.pos);
-                r.placing = Some((target, ticks));
             }
             if reacts {
                 self.predict_use(&changes, seq);
+                self.open_command_block_if_editable((hit.pos[0], hit.pos[1], hit.pos[2]));
             } else if let Some(stack) = held.as_ref()
                 && self.predict_item_on_block(stack, &hit)
             {
@@ -4198,6 +4476,16 @@ impl Game<'_> {
         if self.keys.contains(&KeyCode::ShiftLeft) && hands_full {
             return (false, DryUse::default());
         }
+        // BeehiveBlock.useItemOn: shears or a glass bottle on a full hive
+        // (honey level 5) is SUCCESS, so the click ends after UseItemOn and
+        // no UseItem follows (the server does the harvest, see `use_beehive`).
+        if held.is_some_and(|s| matches!(&*s.item, "minecraft:shears" | "minecraft:glass_bottle"))
+            && self
+                .hive_state(hit.pos)
+                .is_some_and(|(honey, _)| honey == Some(5))
+        {
+            return (true, DryUse::default());
+        }
         use horizon_core::geometry::Direction;
         let face = match hit.face {
             [0, 1, 0] => Direction::Up,
@@ -4307,13 +4595,27 @@ impl Game<'_> {
         let Some(info) = self.res.items().get(&held.item).cloned() else {
             return false;
         };
-        // MultiPlayerGameMode.useItem runs the use here too (inside
-        // startPrediction): the `use_cooldown` component starts its entry, and
-        // the server's ClientboundCooldownPacket confirms it.
-        self.apply_use_cooldown(&held);
-        // Food starts being eaten (Consumable.startConsuming), a book and
-        // quill opens.
-        self.with_hand(hand, |g| g.start_eating(&info));
+        // MultiPlayerGameMode.useItem's prediction: an item cooling down
+        // passes (its packet still goes).
+        let group = horizon_client::cooldowns::group(&held, info.use_cooldown.as_ref());
+        if self.cooldowns.is_on_cooldown(&group) {
+            return false;
+        }
+        // Food starts being eaten (Consumable.startConsuming). A food that
+        // can't be eaten (full and not always-edible) fails the use
+        // (InteractionResult.FAIL): startUseItem tries the other hand, and
+        // no cooldown or use animation starts.
+        let eating = self.with_hand(hand, |g| g.start_eating(&info));
+        if info.food.is_some() && !eating {
+            return false;
+        }
+        // It runs the use here too: ItemStack.use starts the `use_cooldown`
+        // of an item with no use time, and the server's
+        // ClientboundCooldownPacket confirms it; one held in use starts it at
+        // finishUsingItem (remote_complete_using).
+        if !info.consumable.as_ref().is_some_and(|c| c.ticks() > 0) {
+            self.apply_use_cooldown(&held);
+        }
         if self.with_hand(hand, |g| g.remote_use_book(&held)) {
             return true;
         }
@@ -4385,14 +4687,25 @@ impl Game<'_> {
         self.remote_use_item(Hand::Off);
     }
     /// `LivingEntity.updatingUsingItem` on a server client: an item held in
-    /// use (`held_until_released`), and a
-    /// consumable's eating animation and its crumbs. The server eats it and
-    /// sends the stack, the hunger and the sounds.
+    /// use (`held_until_released`), and a consumable's eating animation and
+    /// its crumbs until the server's USE_ITEM_COMPLETE. The server sends the
+    /// stack, its hunger and the sounds.
     fn remote_tick_using(&mut self) {
         let Some((slot, ticks)) = self.using else {
             return;
         };
         let stack = self.stack_in(slot).cloned();
+        // The use stops when the hand no longer holds the item it began with
+        // (ItemStack.isSameItem).
+        let item = stack.as_ref().map(|s| Arc::clone(&s.item));
+        if let Some(r) = self.remote.as_mut() {
+            if ticks == 0 {
+                r.use_item = item;
+            } else if r.use_item != item {
+                self.using = None;
+                return;
+            }
+        }
         // Another hotbar slot picked: LivingEntity.updatingUsingItem sees a
         // different stack in the hand. The off hand keeps its item.
         let in_hand = slot == self.selected || slot == super::shield::OFFHAND_SLOT;
@@ -4417,20 +4730,51 @@ impl Game<'_> {
             self.using = None;
             return;
         }
-        // Consumable.shouldEmitParticlesAndSounds, as in tick_used_item.
-        let duration = consumable.ticks().max(0) as u32;
-        let remaining = duration - ticks.min(duration);
-        if consumable.particles && consumable.should_emit(remaining as i32) {
+        // Consumable.startConsuming eats one with no use time at once, without
+        // a use (nor a USE_ITEM_COMPLETE).
+        if consumable.ticks() <= 0 {
+            self.using = None;
+            return;
+        }
+        // Consumable.shouldEmitParticlesAndSounds, as in tick_used_item. The
+        // countdown goes on past zero (LivingEntity.updateUsingItem completes
+        // only on the server) until the server's USE_ITEM_COMPLETE.
+        let remaining = consumable.ticks() - ticks as i32;
+        if consumable.particles && consumable.should_emit(remaining) {
             self.eat_particles(&stack, 5);
         }
-        if ticks + 1 >= duration {
-            self.using = None;
-            if consumable.particles {
-                self.eat_particles(&stack, 16);
-            }
-        } else {
-            self.using = Some((slot, ticks + 1));
+        self.using = Some((slot, ticks + 1));
+    }
+    /// `Player.handleEntityEvent(9)`: `completeUsingItem` on the client. A consumable's last crumbs, and FoodProperties.onConsume,
+    /// which runs on the client too (Consumable.onConsume calls its
+    /// ConsumableListeners on both sides): the client's FoodData eats at once,
+    /// so a held right click finds `Player.canEat` false instead of starting
+    /// another bite before the server's ClientboundSetHealth arrives.
+    fn remote_complete_using(&mut self) {
+        let Some((slot, _)) = self.using.take() else {
+            return;
+        };
+        let Some(stack) = self.stack_in(slot).cloned() else {
+            return;
+        };
+        let Some(info) = self.res.items().get(&stack.item).cloned() else {
+            return;
+        };
+        if info.consumable.as_ref().is_some_and(|c| c.particles) {
+            self.eat_particles(&stack, 16);
         }
+        if let Some((nutrition, saturation)) = info.food
+            && let Some(r) = self.remote.as_mut()
+        {
+            // FoodData.eat(nutrition, saturation), as finish_consuming does;
+            // the next ClientboundSetHealth replaces it.
+            let (_, food, sat) = &mut r.health;
+            *food = (*food + nutrition as i32).clamp(0, 20);
+            *sat = (*sat + saturation).clamp(0.0, *food as f32);
+            self.apply_remote_health();
+        }
+        // ItemStack.finishUsingItem's applyAfterUseComponentSideEffects.
+        self.apply_use_cooldown(&stack);
     }
     /// MouseHandler updates KeyMapping; handleKeybinds sends packets on a tick.
     pub(super) fn remote_mouse(&mut self, button: MouseButton, pressed: bool) -> Result<()> {
@@ -4495,6 +4839,31 @@ impl Game<'_> {
         }
         let (attack, use_item) = (self.left, self.right);
         input.tick(&mut RemoteInputWorld(self), attack, use_item);
+        // handleKeybinds' keybind polls: the queued presses act now, in tick
+        // order, so no packet goes out between CLIENT_TICK_END and a pong.
+        let pending = self
+            .remote
+            .as_mut()
+            .map(|r| std::mem::take(&mut r.pending_keys))
+            .unwrap_or_default();
+        for key in pending {
+            match key {
+                KeyCode::KeyF if !self.spectator() => self.remote_swap_hands(),
+                KeyCode::KeyQ if !self.spectator() => {
+                    let all = self.keys.contains(&KeyCode::ControlLeft);
+                    self.remote_drop(all);
+                }
+                KeyCode::KeyE if self.riding_mount_with_menu() => {
+                    let id = self.remote.as_ref().map_or(0, |r| r.entity_id);
+                    self.send(S::PlayerCommand(play::PlayerCommand {
+                        id,
+                        action: 5,
+                        data: 0,
+                    }));
+                }
+                _ => {}
+            }
+        }
         if self.clicks.miss_time > 0 {
             self.clicks.miss_time -= 1;
         }
@@ -4606,22 +4975,8 @@ impl Game<'_> {
                 if self.spectator() {
                     return Ok(true);
                 }
-                let all = self.keys.contains(&KeyCode::ControlLeft);
-                // MultiPlayerGameMode.dropItem: predict removal before sending
-                // the action, then swing only if a nonempty stack was removed.
-                let dropped = horizon_client::items::take_held_drop(
-                    &mut self.inventory[self.selected],
-                    all,
-                    false,
-                );
-                self.send(S::PlayerAction(play::PlayerAction {
-                    action: if all { 4 } else { 5 },
-                    pos: [0; 3],
-                    direction: 0,
-                    sequence: 0,
-                }));
-                if dropped.is_some() {
-                    self.swing_hand(Hand::Main, SwingAnimation::DEFAULT);
+                if let Some(r) = self.remote.as_mut() {
+                    r.pending_keys.push(key);
                 }
                 Ok(true)
             }
@@ -4629,12 +4984,9 @@ impl Game<'_> {
             // horse or llama, the server opens its inventory
             // (ServerboundPlayerCommandPacket OPEN_INVENTORY).
             KeyCode::KeyE if self.riding_mount_with_menu() => {
-                let id = self.remote.as_ref().map_or(0, |r| r.entity_id);
-                self.send(S::PlayerCommand(play::PlayerCommand {
-                    id,
-                    action: 5,
-                    data: 0,
-                }));
+                if let Some(r) = self.remote.as_mut() {
+                    r.pending_keys.push(key);
+                }
                 Ok(true)
             }
             KeyCode::KeyE => {
@@ -4681,6 +5033,21 @@ impl Game<'_> {
             }));
         }
     }
+    /// MultiPlayerGameMode.dropItem (key.drop): predict the removal, then send
+    /// the action; swing only if a nonempty stack was removed.
+    fn remote_drop(&mut self, all: bool) {
+        let dropped =
+            horizon_client::items::take_held_drop(&mut self.inventory[self.selected], all, false);
+        self.send(S::PlayerAction(play::PlayerAction {
+            action: if all { 4 } else { 5 },
+            pos: [0; 3],
+            direction: 0,
+            sequence: 0,
+        }));
+        if dropped.is_some() {
+            self.swing_hand(Hand::Main, SwingAnimation::DEFAULT);
+        }
+    }
     /// Minecraft.handleKeybinds, key.swapOffhand: the server swaps the hands
     /// (ServerboundPlayerActionPacket SWAP_ITEM_WITH_OFFHAND at BlockPos.ZERO, facing down) and
     /// sends both slots back; nothing is predicted.
@@ -4714,7 +5081,7 @@ impl Game<'_> {
     }
     /// The server's open menu: its window id and menu type (0, "inventory"
     /// when none is open).
-    fn remote_menu(&self) -> (i32, String) {
+    pub(super) fn remote_menu(&self) -> (i32, String) {
         match self.remote.as_ref().and_then(|r| r.menu.clone()) {
             Some((id, name)) => (id, name),
             None => (0, "inventory".to_owned()),
@@ -4804,26 +5171,6 @@ impl Game<'_> {
             }));
         }
     }
-    /// A `ContainerClick` on game slot `internal` of the server's open menu
-    /// (`input` is the ContainerInput ordinal). False when the menu has no
-    /// such slot.
-    pub(super) fn remote_slot_click(&mut self, internal: usize, button: i8, input: i32) -> bool {
-        let (container, menu) = self.remote_menu();
-        let slot = Self::menu_slot_index(&menu, internal);
-        let Some(slot) = slot else { return false };
-        let carried = self.to_network(&self.carried).map(|s| Hashed::of(&s));
-        let state = self.remote.as_ref().map_or(0, |r| r.state_id);
-        self.send(S::ContainerClick(play::ContainerClick {
-            container,
-            state,
-            slot: slot as i16,
-            button,
-            input,
-            changed: Vec::new(),
-            carried,
-        }));
-        true
-    }
     /// The server's open menu is the inventory or a chest-like container
     /// (chests, barrels, ender chests: `generic_9xN`; shulker boxes).
     pub(super) fn remote_storage_open(&self) -> bool {
@@ -5202,6 +5549,11 @@ impl Game<'_> {
             batch.text(atlas, message, (w - tw) / 2.0, 85.0, u32::MAX, true);
         }
     }
+    /// Shared flag 6 of an entity on a server's client (`None` without a server).
+    pub(super) fn remote_glowing(&self, id: u32) -> Option<bool> {
+        let r = self.remote.as_ref()?;
+        Some(r.glowing.contains(&(id as i32)))
+    }
     /// Status for `horizon-ctl status`.
     /// The other players' entities in the level and their names (from the
     /// player list).
diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs
index c6702dfb6..f85a96119 100644
--- a/crates/horizon-client/src/game/remote_mob_data.rs
+++ b/crates/horizon-client/src/game/remote_mob_data.rs
@@ -4,8 +4,9 @@
 //! own simulation, which a client of a server doesn't run.
 use super::Game;
 use horizon_client::mobs::render::{PROFESSIONS, VILLAGER_TYPES};
-use horizon_client::mobs::{Mob, Species, Who, bat, tame};
-use horizon_protocol::entity_data::Value;
+use horizon_client::mobs::{Mob, Species, Who, bat, camel, sniffer, sync, tame};
+use horizon_client::particles::{ParticleOptions, ParticleType};
+use horizon_protocol::entity_data::{Particle, ParticleData, Value};
 use horizon_protocol::registry::Builtin;
 
 /// The values `apply` takes from one SetEntityData packet, by vanilla's entry
@@ -16,10 +17,18 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
     let baby = super::lan::baby_index(&m.kind.id);
     for (index, _, value) in values {
         match (*index, value) {
+            // Entity.DATA_POSE: a player's or mannequin's box follows it.
+            (6, Value::Id(pose))
+                if matches!(&*m.kind.id, "minecraft:player" | "minecraft:mannequin") =>
+            {
+                m.extra.avatar_pose = horizon_client::pose::Pose::from_id(*pose);
+            }
             // Entity.DATA_SHARED_FLAGS_ID's FLAG_ONFIRE: Entity.isOnFire on a
             // client, which draws the flames. A client doesn't count the
             // fire down: the flag goes off when the server's fire is out.
             (0, Value::Byte(flags)) => m.fire_ticks = i32::from(flags & 1),
+            // Entity.DATA_POSE: the pose the species animates by.
+            (6, Value::Id(pose)) => sync::set_pose(m, (*pose).clamp(0, 17) as u8),
             // LivingEntity.DATA_LIVING_ENTITY_FLAGS: using an item 1, in the
             // off hand 2. The flag starts and stops the use; the client ticks
             // the count itself (a bow's pull follows it).
@@ -34,6 +43,10 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
             // LivingEntity.DATA_HEALTH_ID: the boss bars and the death
             // animation follow it.
             (9, Value::Float(health)) => m.health = *health,
+            // LivingEntity.DATA_EFFECT_PARTICLES and DATA_EFFECT_AMBIENCE_ID:
+            // the swirls of its effects (`tickEffects` draws them).
+            (10, Value::Particles(list)) => m.extra.effect_particles = swirls(list, builtin),
+            (11, Value::Bool(ambient)) => m.extra.effect_ambient = *ambient,
             // Mob.DATA_MOB_FLAGS_ID: no AI 1, left-handed 2, aggressive 4.
             // Mob.isAggressive draws the illagers' and skeletons' attack
             // poses and the vindicator's axe.
@@ -59,6 +72,8 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
                     Who::Mob(*target as u32)
                 });
             }
+            // PolarBear.DATA_STANDING_ID: the client animates the rearing.
+            (Species::PolarBear, 18, Value::Bool(standing)) => m.extra.flag = *standing,
             // Bat.DATA_ID_FLAGS: resting in bit 0.
             (Species::Bat, 16, Value::Byte(flags)) => bat::set_resting(m, flags & 1 != 0),
             // Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 sheared.
@@ -66,6 +81,14 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
                 m.extra.color = (*wool & 15) as u8;
                 m.extra.sheared = wool & 16 != 0;
             }
+            // SnowGolem.DATA_PUMPKIN_ID: 16 while the pumpkin is on.
+            (Species::SnowGolem, 16, Value::Byte(flags)) => m.extra.sheared = flags & 16 == 0,
+            // MushroomCow.DATA_TYPE: 0 red, 1 brown.
+            (Species::Mooshroom, 17, Value::Int(variant)) => {
+                m.extra.variant = (*variant == 1) as u8
+            }
+            // Piglin.DATA_IS_DANCING: the dance pose.
+            (Species::Piglin, 19, Value::Bool(dancing)) => m.extra.scratch[0] = i32::from(*dancing),
             // TamableAnimal.DATA_FLAGS_ID: sitting 1, tame 4.
             (Species::Wolf | Species::Cat | Species::Parrot, 18, Value::Byte(flags)) => {
                 m.extra.sitting = flags & 1 != 0;
@@ -79,6 +102,29 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
             (Species::Slime | Species::MagmaCube, 18, Value::Int(size)) => {
                 m.extra.size = (*size).clamp(1, 127);
             }
+            // Warden.CLIENT_ANGER_LEVEL: the heartbeat's pace.
+            (Species::Warden, 16, Value::Int(anger)) => {
+                if let Some(st) = m.extra.warden.as_mut() {
+                    st.client_anger = *anger;
+                }
+            }
+            // Sniffer.DATA_STATE (after AgeableMob's two): the animation
+            // follows it in `sync::client_tick`.
+            (Species::Sniffer, 18, Value::Id(state)) => {
+                sniffer::set_state(m, (*state).clamp(0, 6) as u8);
+            }
+            // Shulker.DATA_ATTACH_FACE_ID, DATA_PEEK_ID and DATA_COLOR_ID.
+            (Species::Shulker, 16, Value::Id(face)) => m.extra.variant3 = (*face).clamp(0, 5) as u8,
+            (Species::Shulker, 17, Value::Byte(peek)) => m.extra.counter = i32::from(*peek),
+            (Species::Shulker, 18, Value::Byte(color)) => m.extra.color = *color as u8,
+            // Camel.DASH and LAST_POSE_CHANGE_TICK (after AbstractHorse's
+            // flags).
+            (Species::Camel | Species::CamelHusk, 19, Value::Bool(dashing)) => {
+                camel::set_dashing(m, *dashing);
+            }
+            (Species::Camel | Species::CamelHusk, 20, Value::Long(tick)) => {
+                camel::set_synced_pose_tick(m, *tick);
+            }
             // Pillager.IS_CHARGING_CROSSBOW: the charge pose (Raider's
             // IS_CELEBRATING takes 16).
             (Species::Pillager, 17, Value::Bool(charging)) => m.extra.flag = *charging,
@@ -100,6 +146,30 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
     }
 }
 
+/// The options of a synched particle list: an entity effect carries its ARGB
+/// colour, the omens none.
+fn swirls(list: &[Particle], builtin: &Builtin) -> Vec<ParticleOptions> {
+    let channel = |argb: i32, shift: u32| ((argb >> shift) & 255) as f32 / 255.0;
+    list.iter()
+        .filter_map(|p| {
+            let name = builtin.get("minecraft:particle_type")?.name(p.id)?;
+            let ty = ParticleType::from_name(name)?;
+            Some(match p.data {
+                Some(ParticleData::Color(argb)) => ParticleOptions::colored(
+                    ty,
+                    [
+                        channel(argb, 16),
+                        channel(argb, 8),
+                        channel(argb, 0),
+                        channel(argb, 24),
+                    ],
+                ),
+                _ => ParticleOptions::simple(ty),
+            })
+        })
+        .collect()
+}
+
 /// VillagerData as the network sends it: the type and the profession by
 /// their built-in registry ids, then the level.
 fn villager_data(m: &mut Mob, data: &[i32], builtin: &Builtin) {
diff --git a/crates/horizon-client/src/game/remote_mob_use.rs b/crates/horizon-client/src/game/remote_mob_use.rs
index 9575cf925..bd38c7301 100644
--- a/crates/horizon-client/src/game/remote_mob_use.rs
+++ b/crates/horizon-client/src/game/remote_mob_use.rs
@@ -66,8 +66,11 @@ impl Game<'_> {
             | Species::Salmon
             | Species::TropicalFish
             | Species::Pufferfish
-            | Species::Axolotl
-            | Species::Tadpole => item == "minecraft:water_bucket",
+            | Species::Axolotl => item == "minecraft:water_bucket",
+            // Tadpole.mobInteract: frog food, else the bucket.
+            Species::Tadpole => {
+                item == "minecraft:water_bucket" || m.kind.food.iter().any(|f| f.as_str() == item)
+            }
             Species::Armadillo => item == "minecraft:brush",
             // ZombieVillager.mobInteract: CONSUME for a golden apple.
             Species::ZombieVillager => item == "minecraft:golden_apple",
diff --git a/crates/horizon-client/src/game/remote_objects.rs b/crates/horizon-client/src/game/remote_objects.rs
index 05b1a2b9e..7f484c35f 100644
--- a/crates/horizon-client/src/game/remote_objects.rs
+++ b/crates/horizon-client/src/game/remote_objects.rs
@@ -1,9 +1,10 @@
-//! Boats, minecarts, armor stands, item frames and paintings on a server's
+//! Boats, minecarts, armor stands, item frames, paintings and fence knots on a server's
 //! client (`ClientPacketListener.handleAddEntity`, `handleSetEntityData`,
 //! `handleSetEquipment`): the server simulates them, the client places them
 //! where it says and interpolates their moves like a mob's.
 use super::Game;
 use horizon_client::entities::{ArmorStand, Cushion, ItemFrame, Painting};
+use horizon_client::mobs::leash::Holder;
 use horizon_core::geometry::Vec3;
 use horizon_protocol::entity_data::Value;
 use std::sync::Arc;
@@ -24,7 +25,17 @@ impl Game<'_> {
         let at = Vec3::new(position[0], position[1], position[2]);
         let block = position.map(|v| v.floor() as i32);
         self.remove_remote_object(id);
-        if kind == "minecraft:text_display" {
+        if kind == "minecraft:leash_knot" {
+            // A lead that came before its knot waits as a mob holder with the
+            // knot's id (handleEntityLinkPacket's delayed holder); now it can
+            // be tied to the fence.
+            self.remote_knots.insert(id, block);
+            for m in &mut self.mobs {
+                if m.extra.leash == Some(Holder::Mob(id)) {
+                    m.extra.leash = Some(Holder::Knot(block));
+                }
+            }
+        } else if kind == "minecraft:text_display" {
             self.text_displays.insert(
                 id as i32,
                 super::text_displays::RemoteTextDisplay::new(position, yaw),
@@ -304,6 +315,7 @@ impl Game<'_> {
     /// Every object a server sent (a new connection, level or dimension).
     pub(super) fn clear_remote_objects(&mut self) {
         self.text_displays.clear();
+        self.remote_knots.clear();
         self.carts.clear();
         self.boats.clear();
         self.armor_stands.clear();
@@ -314,6 +326,7 @@ impl Game<'_> {
 
     pub(super) fn remove_remote_object(&mut self, id: u32) {
         self.text_displays.remove(&(id as i32));
+        self.remote_knots.remove(&id);
         self.carts.retain(|c| c.id != id);
         self.boats.retain(|b| b.id != id);
         self.armor_stands.retain(|a| a.id != id);
diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs
index 133c2b9fd..409c28c88 100644
--- a/crates/horizon-client/src/game/remote_projectiles.rs
+++ b/crates/horizon-client/src/game/remote_projectiles.rs
@@ -3,8 +3,11 @@
 //! and `handleSetEntityData`): the server simulates them, the client draws
 //! them where it says and interpolates their moves.
 use super::{FallStep, FallingBlock, Game, fireworks::fireworks_of, view_vector};
-use horizon_client::particles::{ParticleOptions, ParticleType};
 use horizon_client::projectiles::{Hit, Projectile, ProjectileKind, ProjectileWorld};
+use horizon_client::{
+    collisions::SceneCollisions,
+    particles::{ParticleOptions, ParticleType},
+};
 use horizon_core::{geometry::Vec3, position::BlockPos, random::RandomSource};
 use horizon_protocol::entity_data::Value;
 use horizon_world::registry::BlockStateId;
@@ -23,6 +26,59 @@ fn default_cloud_particle() -> ParticleOptions {
     ParticleOptions::colored(ParticleType::EntityEffect, [1.0; 4])
 }
 
+/// `AreaEffectCloud.clientTick`: while waiting, now and then two particles
+/// near the middle; then about one per square block of the disc, drifting
+/// (an entity effect stays still).
+pub(super) fn cloud_client_tick(
+    particles: &mut horizon_client::particles::ParticleEngine,
+    at: [f64; 3],
+    radius: f32,
+    waiting: bool,
+    particle: &ParticleOptions,
+) {
+    if waiting && particles.random().next_boolean() {
+        return;
+    }
+    let (count, spread) = if waiting {
+        (2, 0.2)
+    } else {
+        (
+            (std::f32::consts::PI * radius * radius).ceil() as i32,
+            radius,
+        )
+    };
+    for _ in 0..count {
+        let r = particles.random();
+        let angle = r.next_float() * std::f32::consts::TAU;
+        let distance = r.next_float().sqrt() * spread;
+        let at = [
+            at[0] + f64::from(angle.cos() * distance),
+            at[1],
+            at[2] + f64::from(angle.sin() * distance),
+        ];
+        let (options, velocity) = if particle.ty == ParticleType::EntityEffect {
+            let default = waiting && r.next_boolean();
+            let options = if default {
+                default_cloud_particle()
+            } else {
+                particle.clone()
+            };
+            (options, [0.0; 3])
+        } else if waiting {
+            (particle.clone(), [0.0; 3])
+        } else {
+            let v = [
+                (0.5 - r.next_double()) * 0.15,
+                f64::from(0.01f32),
+                (0.5 - r.next_double()) * 0.15,
+            ];
+            (particle.clone(), v)
+        };
+        // `addAlwaysVisibleParticle`.
+        particles.add_with(&options, at, velocity, false, true);
+    }
+}
+
 /// The projectile a type id names, as Horizon models it.
 fn projectile_kind(kind: &str) -> Option<ProjectileKind> {
     Some(match kind {
@@ -77,8 +133,36 @@ fn remote_arrow_tick(p: &mut Projectile, w: &impl ProjectileWorld) {
     }
     p.velocity.y -= 0.05;
 }
+/// A server's client ticks a projectile itself: it flies on between the
+/// tracker's updates (10 to 20 ticks apart) with its own gravity and drag,
+/// and a block stops it there; only the server decides what it hits.
+pub(super) fn remote_projectile_tick(p: &mut Projectile, w: &impl ProjectileWorld) {
+    if !matches!(p.tick(w).1, Hit::None) {
+        p.velocity = Vec3::ZERO;
+    }
+}
+
+/// `AbstractHurtingProjectile.getTrailParticle`: smoke for every one of them
+/// but the wind charges (no trail) and the dragon's fireball (its own).
+pub(super) fn has_smoke_trail(kind: &ProjectileKind) -> bool {
+    matches!(
+        kind,
+        ProjectileKind::SmallFireball
+            | ProjectileKind::LargeFireball { .. }
+            | ProjectileKind::WitherSkull { .. }
+    )
+}
 
 impl Game<'_> {
+    /// `AbstractHurtingProjectile.createParticleTrail`: one smoke puff half a
+    /// block above each position.
+    pub(super) fn smoke_trails(&mut self, at: impl IntoIterator<Item = Vec3>) {
+        let smoke = ParticleOptions::simple(ParticleType::Smoke);
+        for p in at {
+            self.particles.add(&smoke, [p.x, p.y + 0.5, p.z], [0.0; 3]);
+        }
+    }
+
     /// `handleAddEntity` for these types; false when `kind` isn't one.
     pub(super) fn spawn_remote_projectile(
         &mut self,
@@ -95,6 +179,7 @@ impl Game<'_> {
         let (yaw, pitch) = rotation;
         self.remove_remote_projectile(id);
         match kind {
+            "minecraft:evoker_fangs" => self.insert_fangs(id, position, yaw, 0, 0),
             "minecraft:tnt" => self.tnts.push(super::tnt::PrimedTnt {
                 id,
                 position: at,
@@ -163,12 +248,16 @@ impl Game<'_> {
                 let Some(k) = projectile_kind(kind) else {
                     return false;
                 };
+                if k == ProjectileKind::LlamaSpit {
+                    self.particles
+                        .llama_spit_burst(position, [velocity.x, velocity.y, velocity.z]);
+                }
                 let mut p = Projectile::new(k, at, None);
                 p.id = id;
                 p.velocity = velocity;
                 p.yaw = yaw;
                 p.pitch = pitch;
-                self.creatures.projectiles.push(p);
+                self.add_projectile(p);
             }
         }
         true
@@ -326,6 +415,7 @@ impl Game<'_> {
 
     /// One tick of interpolation, as `tick_remote_objects`.
     pub(super) fn tick_remote_projectiles(&mut self, mut step: impl FnMut(u32, Vec3) -> Vec3) {
+        self.tick_remote_fangs();
         // PrimedTnt.tick runs on a client too: it falls, bounces and burns its
         // fuse down (the swell and flash follow it) between the server's
         // updates (every 10 ticks), and a client discards it when the fuse
@@ -372,11 +462,7 @@ impl Game<'_> {
                         p.age += 1;
                         p.position = p.position.add_vector(p.velocity);
                     }
-                    _ => {
-                        if !matches!(p.tick(&world).1, Hit::None) {
-                            p.velocity = Vec3::ZERO;
-                        }
-                    }
+                    _ => remote_projectile_tick(p, &world),
                 }
             }
             for t in &mut tridents {
@@ -385,31 +471,66 @@ impl Game<'_> {
         }
         self.creatures.projectiles = projectiles;
         self.tridents = tridents;
-        // FireworkRocketEntity.tick: a rocket attached to the gliding local
-        // player boosts it client-side too (attachedToEntity.isFallFlying).
+        let trails: Vec<Vec3> = self
+            .creatures
+            .projectiles
+            .iter()
+            .filter(|p| has_smoke_trail(&p.kind))
+            .map(|p| p.position)
+            .collect();
+        self.smoke_trails(trails);
+        // FireworkRocketEntity.tick: a rocket attached to an entity follows it
+        // and boosts it client-side too (attachedToEntity.isFallFlying), and
+        // every rocket leaves its spark trail on a client.
         let me = self
             .remote
             .as_ref()
             .and_then(|r| u32::try_from(r.entity_id).ok());
-        for r in &mut self.rockets {
-            let id = r.id;
-            r.remote_step(|at| step(id, at));
-            if me.is_some()
-                && r.attached_to == me
-                && let Some(p) = self.player.as_mut()
-                && p.fall_flying
-            {
-                let look = view_vector(self.yaw, self.pitch);
-                let m = p.velocity;
-                p.velocity = Vec3::new(
-                    m.x + look[0] * 0.1 + (look[0] * 1.5 - m.x) * 0.5,
-                    m.y + look[1] * 0.1 + (look[1] * 1.5 - m.y) * 0.5,
-                    m.z + look[2] * 0.1 + (look[2] * 1.5 - m.z) * 0.5,
-                );
-                r.position = p.position;
-                r.velocity = p.velocity;
+        let mut rockets = std::mem::take(&mut self.rockets);
+        for r in &mut rockets {
+            r.remote_step(&mut SceneCollisions {
+                world: &self.world,
+                binding: self.collision,
+                subject: None,
+            });
+            if let Some(target) = r.attached_to {
+                if me == Some(target) {
+                    if let Some(p) = self.player.as_mut() {
+                        if p.fall_flying {
+                            let look = view_vector(self.yaw, self.pitch);
+                            let m = p.velocity;
+                            p.velocity = Vec3::new(
+                                m.x + look[0] * 0.1 + (look[0] * 1.5 - m.x) * 0.5,
+                                m.y + look[1] * 0.1 + (look[1] * 1.5 - m.y) * 0.5,
+                                m.z + look[2] * 0.1 + (look[2] * 1.5 - m.z) * 0.5,
+                            );
+                        }
+                        r.position = p.position;
+                        r.velocity = p.velocity;
+                    }
+                } else if let Some(m) = self.mobs.iter().find(|m| m.id == target) {
+                    // Another player's motion is not known here: its step.
+                    r.velocity = Vec3::new(
+                        m.position.x - r.previous.x,
+                        m.position.y - r.previous.y,
+                        m.position.z - r.previous.z,
+                    );
+                    r.position = m.position;
+                }
             }
+            let g = |g: &mut horizon_core::random::LegacyRandom| g.next_gaussian() * 0.05;
+            let v = [
+                g(&mut self.world.random),
+                -r.velocity.y * 0.5,
+                g(&mut self.world.random),
+            ];
+            self.particles.add(
+                &ParticleOptions::simple(ParticleType::Firework),
+                [r.position.x, r.position.y, r.position.z],
+                v,
+            );
         }
+        self.rockets = rockets;
         for c in &mut self.crystals {
             c.time += 1;
             c.position = step(c.id, c.position);
@@ -439,56 +560,15 @@ impl Game<'_> {
         }
     }
 
-    /// `AreaEffectCloud.clientTick`: while waiting, now and then two
-    /// particles near the middle; then about one per square block of the
-    /// disc, drifting (an entity effect stays still).
+    /// `AreaEffectCloud.clientTick` for each cloud a server tracks.
     fn tick_remote_clouds(&mut self) {
         for c in &self.potions.clouds {
-            let r = self.particles.random();
-            if c.waiting && r.next_boolean() {
-                continue;
-            }
-            let (count, spread) = if c.waiting {
-                (2, 0.2)
-            } else {
-                (
-                    (std::f32::consts::PI * c.radius * c.radius).ceil() as i32,
-                    c.radius,
-                )
-            };
-            for _ in 0..count {
-                let r = self.particles.random();
-                let angle = r.next_float() * std::f32::consts::TAU;
-                let distance = r.next_float().sqrt() * spread;
-                let at = [
-                    c.at[0] + f64::from(angle.cos() * distance),
-                    c.at[1],
-                    c.at[2] + f64::from(angle.sin() * distance),
-                ];
-                let (options, velocity) = if c.particle.ty == ParticleType::EntityEffect {
-                    let default = c.waiting && r.next_boolean();
-                    let options = if default {
-                        default_cloud_particle()
-                    } else {
-                        c.particle.clone()
-                    };
-                    (options, [0.0; 3])
-                } else if c.waiting {
-                    (c.particle.clone(), [0.0; 3])
-                } else {
-                    let v = [
-                        (0.5 - r.next_double()) * 0.15,
-                        f64::from(0.01f32),
-                        (0.5 - r.next_double()) * 0.15,
-                    ];
-                    (c.particle.clone(), v)
-                };
-                self.particles.add(&options, at, velocity);
-            }
+            cloud_client_tick(&mut self.particles, c.at, c.radius, c.waiting, &c.particle);
         }
     }
 
     pub(super) fn remove_remote_projectile(&mut self, id: u32) {
+        self.fangs.list.retain(|f| f.id != id);
         self.tnts.retain(|t| t.id != id);
         self.falling.retain(|f| f.id != id);
         self.creatures.projectiles.retain(|p| p.id != id);
@@ -504,6 +584,7 @@ impl Game<'_> {
 
     /// Every one a server sent (a new connection, level or dimension).
     pub(super) fn clear_remote_projectiles(&mut self) {
+        self.fangs.list.clear();
         self.tnts.clear();
         self.falling.clear();
         self.creatures.projectiles.clear();
@@ -524,6 +605,12 @@ impl Game<'_> {
         use serde_json::json;
         let at = |p: Vec3| [p.x, p.y, p.z];
         let mut out = Vec::new();
+        for f in &self.fangs.list {
+            out.push(
+                json!({"id": f.id, "kind": "minecraft:evoker_fangs", "position": f.pos,
+                "yaw": f.yaw, "started": f.started, "life": f.life}),
+            );
+        }
         for t in &self.tnts {
             out.push(json!({"id": t.id, "kind": "minecraft:tnt", "position": at(t.position), "fuse": t.fuse}));
         }
@@ -550,3 +637,68 @@ impl Game<'_> {
         out
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use horizon_client::mobs::Who;
+    use horizon_core::geometry::Aabb;
+
+    /// A world with nothing in it: the client tick of a projectile only
+    /// needs the blocks around it.
+    struct Empty;
+    impl ProjectileWorld for Empty {
+        fn clip(&self, _: Vec3, _: Vec3) -> Option<(Vec3, [i32; 3], [i32; 3])> {
+            None
+        }
+        fn in_water(&self, _: Vec3) -> bool {
+            false
+        }
+        fn targets(&self) -> &[(Who, Aabb)] {
+            &[]
+        }
+    }
+
+    /// A thrown item, as a server's client tracks it: the spawn position and
+    /// the motion the server gave it.
+    fn thrown(kind: ProjectileKind) -> Projectile {
+        let mut p = Projectile::new(kind, Vec3::new(0.0, 100.0, 0.0), None);
+        p.velocity = Vec3::new(1.5, 0.0, 0.0);
+        p
+    }
+
+    #[test]
+    fn a_thrown_item_flies_on_between_the_server_updates() {
+        // A thrown egg, an ender pearl and a wind charge (#1762): the server
+        // sends their position every 10 ticks, and the client ticks them
+        // itself in between, as vanilla's no-op interpolation handler does.
+        for kind in [
+            ProjectileKind::Egg,
+            ProjectileKind::EnderPearl,
+            ProjectileKind::WindCharge,
+        ] {
+            let mut p = thrown(kind);
+            remote_projectile_tick(&mut p, &Empty);
+            assert!(p.position.x > 1.0, "the projectile did not fly on: {p:?}");
+            // A second tick moves it further: it keeps flying, not a hop.
+            let first = p.position.x;
+            remote_projectile_tick(&mut p, &Empty);
+            assert!(p.position.x > first, "the projectile stopped: {p:?}");
+        }
+    }
+
+    #[test]
+    fn a_thrown_item_falls_and_drags_like_a_throwable_projectile() {
+        // ThrowableProjectile.tick: gravity 0.03, then the air drag 0.99.
+        let mut p = thrown(ProjectileKind::Egg);
+        remote_projectile_tick(&mut p, &Empty);
+        assert!((p.velocity.x - 1.5 * 0.99).abs() < 1e-9, "{p:?}");
+        assert!((p.velocity.y - (-0.03 * 0.99)).abs() < 1e-9, "{p:?}");
+        // A wind charge keeps its speed: no gravity and no drag
+        // (AbstractWindCharge: acceleration 0, inertia 1).
+        let mut p = thrown(ProjectileKind::WindCharge);
+        remote_projectile_tick(&mut p, &Empty);
+        assert!((p.velocity.x - 1.5).abs() < 1e-9, "{p:?}");
+        assert!((p.velocity.y - 0.0).abs() < 1e-9, "{p:?}");
+    }
+}
diff --git a/crates/horizon-client/src/game/render_control.rs b/crates/horizon-client/src/game/render_control.rs
index 0a2f9b715..7c5ff4b2d 100644
--- a/crates/horizon-client/src/game/render_control.rs
+++ b/crates/horizon-client/src/game/render_control.rs
@@ -19,33 +19,7 @@ pub const HELP: &[&str] = &[
 impl Game<'_> {
     /// Parse `name[k=v,...]` into a registry state (defaults for missing properties).
     fn parse_state(&self, text: &str) -> Result<BlockStateId> {
-        let (name, props) = match text.split_once('[') {
-            Some((n, rest)) => (n, rest.trim_end_matches(']')),
-            None => (text, ""),
-        };
-        let name = if name.contains(':') {
-            name.to_owned()
-        } else {
-            format!("minecraft:{name}")
-        };
-        let registry = &self.pack.assets.registry;
-        let default = registry
-            .default_state(&name)
-            .ok_or_else(|| format!("unknown block {name}"))?;
-        let mut state = registry
-            .state(default)
-            .ok_or("missing default state")?
-            .clone();
-        for pair in props.split(',').filter(|p| !p.is_empty()) {
-            let (k, v) = pair
-                .split_once('=')
-                .ok_or_else(|| format!("bad property {pair}"))?;
-            if !state.properties.contains_key(k) {
-                return Err(format!("{name} has no property {k}").into());
-            }
-            state.properties.insert(k.to_owned(), v.to_owned());
-        }
-        Ok(registry.resolve(&state)?)
+        parse_state(self.pack.assets.registry, text)
     }
     pub(super) fn render_command(&mut self, words: &[&str]) -> Result<Option<Value>> {
         let int = |i: usize| -> Result<i32> {
@@ -137,3 +111,36 @@ impl Game<'_> {
         }
     }
 }
+
+/// Parse `name[k=v,...]` into a registry state (defaults for missing properties).
+pub(super) fn parse_state(
+    registry: &horizon_world::registry::BlockRegistry,
+    text: &str,
+) -> Result<BlockStateId> {
+    let (name, props) = match text.split_once('[') {
+        Some((n, rest)) => (n, rest.trim_end_matches(']')),
+        None => (text, ""),
+    };
+    let name = if name.contains(':') {
+        name.to_owned()
+    } else {
+        format!("minecraft:{name}")
+    };
+    let default = registry
+        .default_state(&name)
+        .ok_or_else(|| format!("unknown block {name}"))?;
+    let mut state = registry
+        .state(default)
+        .ok_or("missing default state")?
+        .clone();
+    for pair in props.split(',').filter(|p| !p.is_empty()) {
+        let (k, v) = pair
+            .split_once('=')
+            .ok_or_else(|| format!("bad property {pair}"))?;
+        if !state.properties.contains_key(k) {
+            return Err(format!("{name} has no property {k}").into());
+        }
+        state.properties.insert(k.to_owned(), v.to_owned());
+    }
+    Ok(registry.resolve(&state)?)
+}
diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs
index e013c8d29..fecb58615 100644
--- a/crates/horizon-client/src/game/render_tick.rs
+++ b/crates/horizon-client/src/game/render_tick.rs
@@ -7,6 +7,7 @@ use horizon_client::{
     biome::Biomes,
     blocks::{BlockFacts, Fluid},
     chunk::{HEIGHT, MIN_Y},
+    containers::BlockEntity,
     particles::{ParticleLevel, ParticleOptions, ParticleType},
     world::World,
 };
@@ -244,6 +245,7 @@ impl Game<'_> {
                 1.0,
             );
         }
+        self.particles.particle_level = self.settings.particles;
         if let Some(e) = eye {
             self.particles.camera = e;
         }
@@ -287,12 +289,16 @@ impl Game<'_> {
                 e[2].floor() as i32,
             ];
             animate_tick(self.res.animate(), &mut self.particles, &ctx, block);
-            if rain > 0.0 {
-                // ClientLevel.tickWeatherEffects: rain splashes (weather radius 10).
+            // The Horizon Weather option off means no rain visuals or sounds at all.
+            if rain > 0.0 && self.settings.horizon.weather {
+                // ClientLevel.tickWeatherEffects: rain splashes within the weather
+                // radius, and the rain sound.
                 let mut random = LegacyRandom::new(self.world.game_time.wrapping_mul(312_987_231));
-                let radius = 10;
+                let radius = self.settings.weather_radius;
                 let diameter = 2 * radius + 1;
-                let count = (0.225 * (diameter * diameter) as f32 * rain * rain) as i32;
+                let count = (0.225 * (diameter * diameter) as f32 * rain * rain) as i32
+                    / if self.settings.particles == 1 { 2 } else { 1 };
+                let mut rain_position = None;
                 for _ in 0..count {
                     let x = block[0] + random.next_int_bound(diameter).unwrap_or(0) - radius;
                     let z = block[2] + random.next_int_bound(diameter).unwrap_or(0) - radius;
@@ -305,6 +311,12 @@ impl Game<'_> {
                         continue;
                     }
                     let below = top - 1;
+                    rain_position = Some([x, below, z]);
+                    // The Minimal option stops at the first spot that rains (the
+                    // rain sound still plays there).
+                    if self.settings.particles >= 2 {
+                        break;
+                    }
                     let (bx, bz) = (random.next_double(), random.next_double());
                     let state = world.block(x, below, z);
                     let f = facts.get(state);
@@ -336,6 +348,26 @@ impl Game<'_> {
                     self.particles
                         .add(&ParticleOptions::simple(ty), p, [0.0; 3]);
                 }
+                // The last rain column of the tick makes the sound, more often the
+                // longer it has been quiet; indoors it is the quieter one.
+                if let Some(at) = rain_position {
+                    let waited = self.rain_sound_time;
+                    self.rain_sound_time += 1;
+                    if random.next_int_bound(3).unwrap_or(0) < waited {
+                        self.rain_sound_time = 0;
+                        let roof =
+                            motion_blocking(world, facts, block[0], block[2], MIN_Y + HEIGHT);
+                        let (name, volume, pitch) = if at[1] > block[1] + 1 && roof > block[1] {
+                            ("minecraft:weather.rain.above", 0.1, 0.5)
+                        } else {
+                            ("minecraft:weather.rain", 0.2, 1.0)
+                        };
+                        let p = at.map(|c| f64::from(c) + 0.5);
+                        // playLocalSound: guests make their own rain, so a host
+                        // must not capture it for them.
+                        self.audio.play_unshared(name, Some(p), volume, pitch);
+                    }
+                }
             }
         }
         if let Some(r) = &self.renderer {
@@ -344,6 +376,10 @@ impl Game<'_> {
                 &mut self.particles,
                 &ctx,
                 r.block_entities(),
+                &|pos| match self.world.block_entities.get(&(pos[0], pos[1], pos[2])) {
+                    Some(BlockEntity::Campfire(c)) => c.items.each_ref().map(Option::is_some),
+                    _ => [false; 4],
+                },
             );
         }
         let level = ParticleLevel {
diff --git a/crates/horizon-client/src/game/scoreboard.rs b/crates/horizon-client/src/game/scoreboard.rs
index 81c03e288..53323fdbb 100644
--- a/crates/horizon-client/src/game/scoreboard.rs
+++ b/crates/horizon-client/src/game/scoreboard.rs
@@ -132,8 +132,18 @@ impl Game<'_> {
         match t {
             Target::Player => Some(self.acting_player_name().to_owned()),
             Target::Guest(conn) => self.command_guest(conn).map(|g| g.name.clone()),
-            Target::Mob(id) | Target::Item(id) => Some(uuid_text(self.uuid_for(id))),
-            _ => None,
+            Target::Mob(id)
+            | Target::Item(id)
+            | Target::Stand(id)
+            | Target::Frame(id)
+            | Target::Painting(id)
+            | Target::Boat(id)
+            | Target::Cart(id)
+            | Target::Crystal(id)
+            | Target::Dragon(id)
+            | Target::Other(id) => Some(uuid_text(self.uuid_for(id))),
+            // Orbs and projectiles have no UUID here.
+            Target::Orb(_) | Target::Projectile(_) => None,
         }
     }
     fn holder_for(&mut self, t: Target) -> Option<Holder> {
@@ -180,7 +190,11 @@ impl Game<'_> {
             | Target::Cart(id)
             | Target::Other(id) => self.persist.raw.get(&id),
             Target::Player => self.level.player_extra.as_ref(),
-            Target::Guest(_) | Target::Orb(_) | Target::Projectile(_) => None,
+            Target::Guest(_)
+            | Target::Orb(_)
+            | Target::Projectile(_)
+            | Target::Crystal(_)
+            | Target::Dragon(_) => None,
         };
         match raw.and_then(|r| r.get("Tags")) {
             Some(Tag::List(l)) => l
diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs
index f8885f83a..4b5c4c333 100644
--- a/crates/horizon-client/src/game/screens.rs
+++ b/crates/horizon-client/src/game/screens.rs
@@ -19,6 +19,9 @@ impl Screen {
             | Self::Advancements
             | Self::WorldOptions
             | Self::Friends
+            | Self::ServerLinks
+            | Self::ConfirmLink
+            | Self::DialogWarning
             | Self::Mod => true,
             Self::Playing
             | Self::GameModeSwitcher
@@ -35,20 +38,35 @@ impl Screen {
 }
 
 /// PauseScreen buttons: (x, y, width, label key, action id, active).
+/// `links`: the `minecraft:server_links` dialog's button, which the
+/// `pause_screen_additions` tag (empty in vanilla) falls back to when the
+/// server sent links — a full-width row that pushes the last two rows down.
 /// https://mcsrc.dev/2/26.3/net/minecraft/client/gui/screens/PauseScreen
-fn pause_buttons(w: f32, h: f32, remote: bool) -> Vec<(f32, f32, f32, &'static str, u8, bool)> {
+fn pause_buttons(
+    w: f32,
+    h: f32,
+    remote: bool,
+    links: bool,
+) -> Vec<(f32, f32, f32, &'static str, u8, bool)> {
     // GridLayout of two 98px columns (padding 4), aligned at (0.5, 0.25).
-    let (grid_w, grid_h) = (212.0, 166.0);
+    let (grid_w, grid_h) = (212.0, 166.0 + if links { 24.0 } else { 0.0 });
     let x0 = ((w - grid_w) * 0.5).floor();
     let y0 = ((h - grid_h) * 0.25).floor();
-    vec![
+    let down = if links { 24.0 } else { 0.0 };
+    let mut v = vec![
         (x0 + 4.0, y0 + 50.0, 204.0, "menu.returnToGame", 0, true),
         (x0 + 4.0, y0 + 74.0, 98.0, "gui.advancements", 4, true),
         (x0 + 110.0, y0 + 74.0, 98.0, "gui.stats", 3, true),
-        (x0 + 4.0, y0 + 122.0, 98.0, "menu.options", 1, true),
+    ];
+    if links {
+        // CommonDialogData.computeExternalTitle of Dialogs.SERVER_LINKS.
+        v.push((x0 + 4.0, y0 + 122.0, 204.0, "menu.server_links", 11, true));
+    }
+    v.extend([
+        (x0 + 4.0, y0 + 122.0 + down, 98.0, "menu.options", 1, true),
         (
             x0 + 110.0,
-            y0 + 122.0,
+            y0 + 122.0 + down,
             98.0,
             "options.worldOptions.button",
             9,
@@ -56,7 +74,7 @@ fn pause_buttons(w: f32, h: f32, remote: bool) -> Vec<(f32, f32, f32, &'static s
         ),
         (
             x0 + 4.0,
-            y0 + 146.0,
+            y0 + 146.0 + down,
             204.0,
             if remote {
                 "menu.disconnect"
@@ -66,16 +84,17 @@ fn pause_buttons(w: f32, h: f32, remote: bool) -> Vec<(f32, f32, f32, &'static s
             2,
             true,
         ),
-    ]
+    ]);
+    v
 }
 
 /// The icon row: report bugs, feedback, friends, player reporting.
 /// `FRIENDS_ICON` (vanilla's `CommonButtons.friends`) opens Horizon's
 /// Play with Friends; the others stay inactive.
 const FRIENDS_ICON: usize = 2;
-fn pause_icons(w: f32, h: f32) -> [(f32, f32, &'static str); 4] {
+fn pause_icons(w: f32, h: f32, links: bool) -> [(f32, f32, &'static str); 4] {
     let x0 = ((w - 212.0) * 0.5).floor() + 60.0;
-    let y = ((h - 166.0) * 0.25).floor() + 98.0;
+    let y = ((h - 166.0 - if links { 24.0 } else { 0.0 }) * 0.25).floor() + 98.0;
     [
         (x0, y, "gui/sprites/pause_menu/bug"),
         (x0 + 24.0, y, "gui/sprites/pause_menu/social_interactions"),
@@ -120,7 +139,9 @@ impl Game<'_> {
             u32::MAX,
             true,
         );
-        for (x, y, bw, key, _, active) in pause_buttons(w, h, self.external_server()) {
+        let links = !self.server_links().is_empty();
+        let mut tooltip = None;
+        for (x, y, bw, key, id, active) in pause_buttons(w, h, self.external_server(), links) {
             let hover = active && ui::hovered(self.cursor, x, y, bw, 20.0);
             ui::button(
                 batch,
@@ -133,9 +154,12 @@ impl Game<'_> {
                 active,
                 hover,
             );
+            // PauseScreen's customAdditions button: CUSTOM_OPTIONS_TOOLTIP.
+            if id == 11 && hover {
+                tooltip = Some(Text::translate("menu.custom_options.tooltip", &[]));
+            }
         }
-        let mut tooltip = None;
-        for (i, (x, y, sprite)) in pause_icons(w, h).into_iter().enumerate() {
+        for (i, (x, y, sprite)) in pause_icons(w, h, links).into_iter().enumerate() {
             let active = i == FRIENDS_ICON && friends;
             let hover = ui::hovered(self.cursor, x, y, 20.0, 20.0);
             // The icon has no label: name it for controller focus and the
@@ -168,7 +192,13 @@ impl Game<'_> {
         }
         // SpriteIconButton.withTootip: the label as a tooltip.
         if let Some(tip) = tooltip {
-            ui::tooltip(batch, atlas, &[tip], self.cursor);
+            let lines: Vec<Text> = atlas
+                .font
+                .split_lines(&tip, batch.width)
+                .into_iter()
+                .map(|(line, _)| line)
+                .collect();
+            ui::tooltip(batch, atlas, &lines, self.cursor);
         }
     }
     pub(super) fn pause_click(&mut self) -> Result<()> {
@@ -180,8 +210,9 @@ impl Game<'_> {
             let b = HudBatch::new(size);
             (b.width, b.height)
         };
-        let friends = pause_icons(w, h)[FRIENDS_ICON];
-        let hit = pause_buttons(w, h, self.external_server())
+        let links = !self.server_links().is_empty();
+        let friends = pause_icons(w, h, links)[FRIENDS_ICON];
+        let hit = pause_buttons(w, h, self.external_server(), links)
             .into_iter()
             .find(|b| b.5 && ui::hovered(self.cursor, b.0, b.1, b.2, 20.0))
             .map(|b| b.4)
@@ -200,6 +231,11 @@ impl Game<'_> {
             Some(4) => self.open_advancements(true),
             Some(9) => self.open_world_options(),
             Some(10) => self.screen = Screen::Friends,
+            // DialogConnectionAccess.openDialog(Dialogs.SERVER_LINKS).
+            Some(11) => {
+                self.links_ui.scroll = 0.0;
+                self.screen = Screen::ServerLinks;
+            }
             Some(2) => self.close_world()?,
             _ => {}
         }
@@ -286,6 +322,58 @@ impl Game<'_> {
             );
         }
     }
+    /// LocalPlayer.respawn: the player comes back (the death screen's
+    /// button, or at once with `immediate_respawn`).
+    pub(super) fn respawn_player(&mut self) -> Result<()> {
+        if self.remote.is_none() {
+            // PlayerList.respawn removes the dead player, and Player.remove's
+            // inventoryMenu.removed drops what the cursor held, whatever
+            // keep_inventory says (the 20-tick branch handles a later respawn).
+            if let Some(stack) = self.carried.take()
+                && let Some(eye) = self.eye_position()
+            {
+                self.throw_from_eyes(stack, eye, false);
+            }
+            let keep = self.ui.rules.bool("keep_inventory") || self.spectator();
+            self.experience.respawn(keep);
+            // The guests are sent the respawned host as a new entity, not the dead body.
+            if let Some(host) = self.lan.as_mut() {
+                let id = host.host_entity;
+                host.hub.respawned(id);
+            }
+            // Autosaves keep a login position; death must resolve the respawn point instead.
+            self.level.position = None;
+        }
+        if self.remote.is_some() {
+            self.ui.death_text = None;
+            self.toggles.respawn();
+            self.remote_respawn();
+        } else if self.respawn_config.is_some() {
+            // LocalPlayer.respawn: KeyMapping.resetToggleKeys.
+            self.toggles.respawn();
+            // PlayerList.respawn at the respawn anchor, once it is loaded.
+            self.begin_anchor_respawn()?;
+            self.screen = Screen::Playing;
+            self.ui.death_text = None;
+            self.spawn_player()?;
+            self.capture(true);
+        } else {
+            // LocalPlayer.respawn: KeyMapping.resetToggleKeys.
+            self.toggles.respawn();
+            self.respawn_out_of_end()?;
+            self.player = None;
+            self.screen = Screen::Playing;
+            self.ui.death_text = None;
+            self.spawn_player()?;
+            self.capture(true);
+        }
+        // ServerGamePacketListenerImpl.handleClientCommand: a hardcore world's
+        // respawned player only watches.
+        if self.remote.is_none() && self.level.hardcore {
+            self.set_mode(GameMode::Spectator);
+        }
+        Ok(())
+    }
     pub(super) fn death_click(&mut self) -> Result<()> {
         if self
             .ui
@@ -303,51 +391,11 @@ impl Game<'_> {
             .into_iter()
             .find(|d| ui::hovered(self.cursor, d.0, d.1, 200.0, 20.0))
             .map(|d| d.3);
-        if hit == Some(0) && self.remote.is_none() {
-            let keep = self.ui.rules.bool("keep_inventory") || self.spectator();
-            self.experience.respawn(keep);
-            // The guests are sent the respawned host as a new entity, not the dead body.
-            if let Some(host) = self.lan.as_mut() {
-                let id = host.host_entity;
-                host.hub.respawned(id);
-            }
-            // Autosaves keep a login position; death must resolve the respawn point instead.
-            self.level.position = None;
-        }
         match hit {
-            Some(0) if self.remote.is_some() => {
-                self.ui.death_text = None;
-                self.toggles.respawn();
-                self.remote_respawn();
-            }
-            Some(0) if self.respawn_config.is_some() => {
-                // LocalPlayer.respawn: KeyMapping.resetToggleKeys.
-                self.toggles.respawn();
-                // PlayerList.respawn at the respawn anchor, once it is loaded.
-                self.begin_anchor_respawn()?;
-                self.screen = Screen::Playing;
-                self.ui.death_text = None;
-                self.spawn_player()?;
-                self.capture(true);
-            }
-            Some(0) => {
-                // LocalPlayer.respawn: KeyMapping.resetToggleKeys.
-                self.toggles.respawn();
-                self.respawn_out_of_end()?;
-                self.player = None;
-                self.screen = Screen::Playing;
-                self.ui.death_text = None;
-                self.spawn_player()?;
-                self.capture(true);
-            }
+            Some(0) => self.respawn_player()?,
             Some(1) => self.close_world()?,
             _ => {}
         }
-        // ServerGamePacketListenerImpl.handleClientCommand: a hardcore world's
-        // respawned player only watches.
-        if hit == Some(0) && self.remote.is_none() && self.level.hardcore {
-            self.set_mode(GameMode::Spectator);
-        }
         if hit.is_some() {
             self.audio.play_button_click();
         }
@@ -357,7 +405,7 @@ impl Game<'_> {
 
 #[cfg(test)]
 mod tests {
-    use super::{Screen, pause_buttons};
+    use super::{Screen, pause_buttons, pause_icons};
 
     #[test]
     fn menu_blur_matches_vanilla_screen_backgrounds() {
@@ -390,11 +438,32 @@ mod tests {
     #[test]
     fn pause_menu_uses_disconnect_for_servers_and_keeps_world_options() {
         for (remote, label) in [(false, "menu.returnToMenu"), (true, "menu.disconnect")] {
-            let buttons = pause_buttons(427.0, 240.0, remote);
+            let buttons = pause_buttons(427.0, 240.0, remote, false);
             let quit = buttons.iter().find(|b| b.4 == 2).unwrap();
             assert_eq!(quit.3, label);
             assert!(quit.5);
             assert!(buttons.iter().any(|b| b.4 == 9 && b.5));
         }
     }
+
+    #[test]
+    fn server_links_adds_a_full_width_row_above_options() {
+        let with = pause_buttons(427.0, 240.0, true, true);
+        let without = pause_buttons(427.0, 240.0, true, false);
+        let links = with.iter().find(|b| b.4 == 11).unwrap();
+        assert_eq!(links.2, 204.0);
+        assert_eq!(links.3, "menu.server_links");
+        assert!(links.5);
+        // The icon row sits above it; Options and Disconnect move down 24.
+        let icons = pause_icons(427.0, 240.0, true);
+        let y0_icons = ((240.0f32 - 190.0) * 0.25).floor() + 98.0;
+        assert_eq!(icons[0].1, y0_icons);
+        assert!(links.1 > icons[0].1);
+        for b in &with {
+            if b.4 == 1 || b.4 == 9 || b.4 == 2 {
+                let same = without.iter().find(|o| o.4 == b.4).unwrap();
+                assert_eq!(b.1, same.1 + 24.0 - 6.0, "{}", b.3);
+            }
+        }
+    }
 }
diff --git a/crates/horizon-client/src/game/sculk.rs b/crates/horizon-client/src/game/sculk.rs
index 7916c46a1..65dfede1a 100644
--- a/crates/horizon-client/src/game/sculk.rs
+++ b/crates/horizon-client/src/game/sculk.rs
@@ -1194,14 +1194,14 @@ impl Game<'_> {
 
     /// `LightmapRenderStateExtractor`: the night vision effect's intensity
     /// (`GameRenderer.nightVisionScale`), or conduit power's water vision.
-    pub(super) fn night_vision_intensity(&self) -> f32 {
+    pub(super) fn night_vision_intensity(&self, partial: f32) -> f32 {
         use horizon_client::fog::FogType;
         if let Some(e) = self.potions.effects.get("night_vision") {
             // MobEffectInstance.endsWithin(200); -1 is infinite.
             return if e.duration < 0 || e.duration > 200 {
                 1.0
             } else {
-                0.7 + (e.duration as f32 * std::f32::consts::PI * 0.2).sin() * 0.3
+                0.7 + ((e.duration as f32 - partial) * std::f32::consts::PI * 0.2).sin() * 0.3
             };
         }
         if self.potions.effects.get("conduit_power").is_some()
@@ -1515,6 +1515,16 @@ impl Game<'_> {
     fn tick_entity_events(&mut self) {
         self.tick_player_sculk_events();
         self.tick_mob_sculk_events();
+        // Dropped items are entities too: Entity.applyEffectsFromBlocks.
+        let items: Vec<[f64; 3]> = self
+            .dropped
+            .iter()
+            .filter(|i| i.on_ground)
+            .map(|i| [i.position.x, i.position.y, i.position.z])
+            .collect();
+        for at in items {
+            self.step_on_redstone_ore(at, false);
+        }
     }
 
     /// Entity.move emits on the authoritative server too, for each ServerPlayer.
@@ -1530,6 +1540,9 @@ impl Game<'_> {
         });
         if let Some((at, on_ground, health, flying)) = player {
             let crouch = self.keys.contains(&KeyCode::ShiftLeft);
+            if on_ground && !self.spectator() {
+                self.step_on_redstone_ore(at, crouch);
+            }
             let in_water = self.in_water_at(at);
             self.entity_motion_events(
                 Who::Player,
@@ -1548,6 +1561,26 @@ impl Game<'_> {
         }
     }
 
+    /// `RedStoneOreBlock.stepOn`: standing on the ore lights it, unless the
+    /// entity is stepping carefully (`attack_block` only lights an unlit ore).
+    fn step_on_redstone_ore(&mut self, at: [f64; 3], carefully: bool) {
+        if carefully {
+            return;
+        }
+        // getOnPosLegacy: 0.2 below the feet.
+        let pos = [
+            at[0].floor() as i32,
+            (at[1] - 0.2).floor() as i32,
+            at[2].floor() as i32,
+        ];
+        if matches!(
+            &*self.block_name(pos),
+            "minecraft:redstone_ore" | "minecraft:deepslate_redstone_ore"
+        ) {
+            let _ = self.attack_block(pos);
+        }
+    }
+
     fn tick_mob_sculk_events(&mut self) {
         let snapshot: Vec<(u32, [f64; 3], bool, bool, Species, Option<i64>)> = self
             .mobs
@@ -1565,6 +1598,9 @@ impl Game<'_> {
             })
             .collect();
         for (id, at, on_ground, in_water, species, damaged) in snapshot {
+            if on_ground {
+                self.step_on_redstone_ore(at, false);
+            }
             let emits = !matches!(species, Species::Shulker);
             if emits {
                 self.entity_motion_events(Who::Mob(id), at, on_ground, in_water, false, false);
diff --git a/crates/horizon-client/src/game/server_links.rs b/crates/horizon-client/src/game/server_links.rs
new file mode 100644
index 000000000..85fda71d6
--- /dev/null
+++ b/crates/horizon-client/src/game/server_links.rs
@@ -0,0 +1,487 @@
+//! `ServerLinksDialogScreen`: the pause menu's "Server Links..." button opens
+//! the `minecraft:server_links` dialog (the `pause_screen_additions` tag's
+//! fallback when a server sent ClientboundServerLinksPacket): a scrollable
+//! list of the server's links, each opened through `ConfirmLinkScreen`
+//! (Screen.clickUrlAction), and the `dialog/warning_button`'s
+//! DialogScreen.WarningScreen ("Note about custom screens").
+//! https://mcsrc.dev/2/26.3/net/minecraft/client/gui/screens/dialog/ServerLinksDialogScreen
+use super::{Game, Screen, packs::open_uri};
+use horizon_client::{Result, clipboard::Clipboard, hud::HudBatch, text::Text, ui};
+use horizon_protocol::packets::configuration::{ServerLink, ServerLinkKind};
+
+/// HeaderAndFooterLayout's header and footer heights; the content wants to
+/// start 30 pixels under the header (its `CONTENTS_MARGIN_TOP`).
+const HEADER: f32 = 33.0;
+const FOOTER: f32 = 33.0;
+const CONTENT_TOP: f32 = HEADER + 30.0;
+/// `server_links.json`: `columns` 1, `button_width` 310, `exit_action`'s 200.
+const LINK_WIDTH: f32 = 310.0;
+/// packControlsIntoColumns: rowSpacing 2 under the 20-pixel buttons.
+const ROW: f32 = 22.0;
+/// ScrollableLayout's BOTH reserve (scrollbarSpacing 4 + SCROLLBAR_WIDTH 6).
+const SCROLL_RESERVE: f32 = 10.0;
+/// DialogScreen's `dialog/warning_button` ImageButton.
+const WARNING_BUTTON: f32 = 20.0;
+
+/// The ServerLinks screen's state: ScrollableLayout's scroll and the link
+/// ConfirmLinkScreen is asking about (`Screen::ConfirmLink`).
+#[derive(Default)]
+pub(super) struct LinksUi {
+    pub scroll: f32,
+    pub confirm: Option<String>,
+}
+
+/// `Util.parseAndValidateUntrustedUri`: an absolute `http`/`https` URI
+/// (java.net.URI's scheme then the allowlist; whitespace-free).
+pub(super) fn valid_untrusted_uri(uri: &str) -> bool {
+    let Some(colon) = uri.find(':') else {
+        return false;
+    };
+    let scheme = &uri[..colon];
+    let mut chars = scheme.chars();
+    if !chars.next().is_some_and(|c| c.is_ascii_alphabetic())
+        || !chars.all(|c| c.is_ascii_alphanumeric() || matches!(c, '+' | '-' | '.'))
+    {
+        return false;
+    }
+    if !matches!(scheme.to_ascii_lowercase().as_str(), "http" | "https") {
+        return false;
+    }
+    !uri.chars().any(|c| c.is_control() || c == ' ')
+}
+/// `ClientCommonPacketListenerImpl.handleServerLinks`: keep only the links
+/// that validate, warning about the dropped ones.
+pub(super) fn trusted(links: Vec<ServerLink>) -> Vec<ServerLink> {
+    links
+        .into_iter()
+        .filter(|l| {
+            let ok = valid_untrusted_uri(&l.link);
+            if !ok {
+                log::warn!("Horizon: server sent an invalid link: {}", l.link);
+            }
+            ok
+        })
+        .collect()
+}
+/// `ServerLinks.Entry.displayName`: `known_server_link.<name>` for a known
+/// type (ByIdMap.ZERO reads unknown ids as `report_bug`), the component else.
+fn link_label(link: &ServerLink) -> Text {
+    const KNOWN: [&str; 10] = [
+        "report_bug",
+        "community_guidelines",
+        "support",
+        "status",
+        "feedback",
+        "community",
+        "website",
+        "forums",
+        "news",
+        "announcements",
+    ];
+    match &link.kind {
+        ServerLinkKind::Known(id) => Text::translate(
+            &format!(
+                "known_server_link.{}",
+                KNOWN.get(*id as usize).copied().unwrap_or(KNOWN[0])
+            ),
+            &[],
+        ),
+        ServerLinkKind::Custom(tag) => {
+            horizon_client::scoreboard::comp_text(&horizon_client::scoreboard::tag_to_json(tag))
+        }
+    }
+}
+
+/// The scrolled column of link buttons: content height and, for a list that
+/// fits, the `HeaderAndFooterLayout` contents frame's top.
+fn list_height(n: usize) -> f32 {
+    n as f32 * ROW - 2.0
+}
+fn list_top(h: f32, n: usize) -> f32 {
+    CONTENT_TOP.min(h - FOOTER - list_height(n).min(h - HEADER - FOOTER))
+}
+fn scroll_limit(h: f32, n: usize) -> f32 {
+    (list_height(n) - (h - HEADER - FOOTER)).max(0.0)
+}
+
+/// `ServerLinksScreen`'s buttons as (x, y) over the scrolled content, and the
+/// footer `Back` button's corner. `top` includes the scroll.
+fn link_buttons(w: f32, top: f32, n: usize) -> Vec<(f32, f32)> {
+    let x = ((w - LINK_WIDTH - 2.0 * SCROLL_RESERVE) / 2.0 + SCROLL_RESERVE).floor();
+    (0..n).map(|i| (x, top + i as f32 * ROW)).collect()
+}
+/// The warning button beside the title (DialogScreen's title row: 10 pixels
+/// apart), clamped onto the screen (makeSureWarningButtonIsInBounds).
+fn warning_button(w: f32, h: f32, title_width: f32) -> (f32, f32) {
+    let x = ((w - title_width - 30.0) / 2.0).floor() + title_width + 10.0;
+    let y = ((HEADER - WARNING_BUTTON) / 2.0).floor();
+    if x < 0.0 || y < 0.0 || x > w - WARNING_BUTTON || y > h - WARNING_BUTTON {
+        (0.0f32.max(w - 40.0), 5.0f32.min(h))
+    } else {
+        (x, y)
+    }
+}
+fn back_button(w: f32, h: f32) -> (f32, f32) {
+    (
+        ((w - 200.0) / 2.0).floor(),
+        h - FOOTER + ((FOOTER - 20.0) / 2.0).floor(),
+    )
+}
+
+impl Game<'_> {
+    /// `connection.serverLinks()`: the links the open server sent (empty for
+    /// a world without a connection or one that sent none).
+    pub(super) fn server_links(&self) -> &[ServerLink] {
+        self.remote
+            .as_ref()
+            .map_or(&[], |r| r.server_links.as_slice())
+    }
+    /// DialogScreen over the pause menu: `menu.server_links.title`, the
+    /// scrollable link buttons and `gui.back` in the footer.
+    pub(super) fn draw_server_links(&mut self, batch: &mut HudBatch) {
+        let atlas = &self.gui.atlas;
+        let (w, h) = (batch.width, batch.height);
+        ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true);
+        let links = self.server_links().to_vec();
+        self.links_ui.scroll = self
+            .links_ui
+            .scroll
+            .clamp(0.0, scroll_limit(h, links.len()));
+        let top = list_top(h, links.len()) - self.links_ui.scroll.trunc();
+        // The title row: the title, then 10 pixels on the warning button.
+        let title = Text::translate("menu.server_links.title", &[]);
+        let tw = atlas.font.width_text(&title);
+        let tx = ((w - tw - 30.0) / 2.0).floor();
+        batch.text_styled(atlas, &title, tx, 12.0, u32::MAX, true);
+        let (wx, wy) = warning_button(w, h, tw);
+        let wh = ui::hovered(self.cursor, wx, wy, WARNING_BUTTON, WARNING_BUTTON);
+        horizon_client::widgets::record(
+            "menu.custom_screen_info.tooltip",
+            [wx, wy, WARNING_BUTTON, WARNING_BUTTON],
+            true,
+        );
+        batch.sprite_scaled(
+            atlas,
+            if wh {
+                "gui/sprites/dialog/warning_button_highlighted"
+            } else {
+                "gui/sprites/dialog/warning_button"
+            },
+            wx,
+            wy,
+            WARNING_BUTTON,
+            WARNING_BUTTON,
+            u32::MAX,
+        );
+        let first = batch.vertices.len();
+        let inside = self.cursor.1 >= HEADER && self.cursor.1 < h - FOOTER;
+        for (link, (x, y)) in links.iter().zip(link_buttons(w, top, links.len())) {
+            let hover = inside && ui::hovered(self.cursor, x, y, LINK_WIDTH, 20.0);
+            ui::button(
+                batch,
+                atlas,
+                x,
+                y,
+                LINK_WIDTH,
+                20.0,
+                &link_label(link),
+                true,
+                hover,
+            );
+        }
+        batch.clip_since(first, 0.0, HEADER, w, h - FOOTER);
+        ui::scrollbar(
+            batch,
+            atlas,
+            (w / 2.0).floor() + 155.0 + 4.0,
+            HEADER,
+            h - FOOTER,
+            list_height(links.len()),
+            self.links_ui.scroll.trunc(),
+        );
+        let (bx, by) = back_button(w, h);
+        let hover = ui::hovered(self.cursor, bx, by, 200.0, 20.0);
+        ui::button(
+            batch,
+            atlas,
+            bx,
+            by,
+            200.0,
+            20.0,
+            &Text::translate("gui.back", &[]),
+            true,
+            hover,
+        );
+        if wh {
+            ui::tooltip(
+                batch,
+                atlas,
+                &[Text::translate("menu.custom_screen_info.tooltip", &[])],
+                self.cursor,
+            );
+        }
+    }
+    /// A click on `Screen::ServerLinks`: a link, the warning button or Back.
+    pub(super) fn server_links_click(&mut self) -> Result<()> {
+        let (w, h) = self.gui_size();
+        let links = self.server_links().to_vec();
+        let top = list_top(h, links.len()) - self.links_ui.scroll.trunc();
+        let inside = self.cursor.1 >= HEADER && self.cursor.1 < h - FOOTER;
+        if inside
+            && let Some(i) = link_buttons(w, top, links.len())
+                .iter()
+                .position(|(x, y)| ui::hovered(self.cursor, *x, *y, LINK_WIDTH, 20.0))
+        {
+            self.audio.play_button_click();
+            self.click_link(&links[i].link);
+            return Ok(());
+        }
+        let title = Text::translate("menu.server_links.title", &[]);
+        let tw = self.gui.atlas.font.width_text(&title);
+        let (wx, wy) = warning_button(w, h, tw);
+        if ui::hovered(self.cursor, wx, wy, WARNING_BUTTON, WARNING_BUTTON) {
+            self.audio.play_button_click();
+            self.screen = Screen::DialogWarning;
+            return Ok(());
+        }
+        let (bx, by) = back_button(w, h);
+        if ui::hovered(self.cursor, bx, by, 200.0, 20.0) {
+            self.audio.play_button_click();
+            self.screen = Screen::Paused;
+        }
+        Ok(())
+    }
+    /// `Screen.clickUrlAction`: "Web Links" off ignores the click; "Prompt on
+    /// Links" asks with ConfirmLinkScreen, else the browser opens directly.
+    fn click_link(&mut self, url: &str) {
+        if !self.settings.chat_links {
+            return;
+        }
+        if self.settings.chat_links_prompt {
+            self.links_ui.confirm = Some(url.to_owned());
+            self.screen = Screen::ConfirmLink;
+        } else {
+            open_uri(url);
+        }
+    }
+    /// `ScrollableLayout`'s mouse wheel over the links.
+    pub(super) fn server_links_scroll(&mut self, delta: f32) {
+        let (_, h) = self.gui_size();
+        self.links_ui.scroll = (self.links_ui.scroll - delta * 10.0)
+            .clamp(0.0, scroll_limit(h, self.server_links().len()));
+    }
+    /// `ConfirmLinkScreen` (untrusted): "Are you sure you want to open the
+    /// following website?", the link, the red warning, and Yes / Copy Link to
+    /// Clipboard / No.
+    pub(super) fn draw_confirm_link(&mut self, batch: &mut HudBatch) {
+        let atlas = &self.gui.atlas;
+        let (w, h) = (batch.width, batch.height);
+        ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true);
+        let url = self.links_ui.confirm.clone().unwrap_or_default();
+        let layout = confirm_link_layout(atlas, (w, h), &url);
+        for (line, x, y) in &layout.lines {
+            batch.text_styled(atlas, line, *x, *y, u32::MAX, true);
+        }
+        let labels = ["gui.yes", "gui.copy_link_to_clipboard", "gui.no"];
+        for ((x, y), key) in layout.buttons.iter().zip(labels) {
+            let hover = ui::hovered(self.cursor, *x, *y, 100.0, 20.0);
+            ui::button(
+                batch,
+                atlas,
+                *x,
+                *y,
+                100.0,
+                20.0,
+                &Text::translate(key, &[]),
+                true,
+                hover,
+            );
+        }
+    }
+    /// ConfirmLinkScreen's answer: yes opens the browser, the middle button
+    /// copies the link, no closes; all return to Server Links.
+    pub(super) fn confirm_link_click(&mut self) {
+        let (w, h) = self.gui_size();
+        let url = self.links_ui.confirm.clone().unwrap_or_default();
+        let layout = confirm_link_layout(&self.gui.atlas, (w, h), &url);
+        for (i, (x, y)) in layout.buttons.iter().enumerate() {
+            if !ui::hovered(self.cursor, *x, *y, 100.0, 20.0) {
+                continue;
+            }
+            self.audio.play_button_click();
+            match i {
+                0 => open_uri(&url),
+                1 => {
+                    self.clipboard.set(&url);
+                }
+                _ => {}
+            }
+            self.screen = Screen::ServerLinks;
+            return;
+        }
+    }
+    /// `DialogScreen.WarningScreen`: the custom-screens note, a disconnect
+    /// button ("Custom screen rejected" is the shown reason) and Back.
+    pub(super) fn draw_dialog_warning(&mut self, batch: &mut HudBatch) {
+        let atlas = &self.gui.atlas;
+        let (w, h) = (batch.width, batch.height);
+        ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true);
+        let layout = dialog_warning_layout(atlas, (w, h));
+        for (line, x, y) in &layout.lines {
+            batch.text_styled(atlas, line, *x, *y, u32::MAX, true);
+        }
+        let quit = if self.external_server() {
+            "menu.disconnect"
+        } else {
+            "menu.returnToMenu"
+        };
+        for ((x, y), key) in layout.buttons.into_iter().zip([quit, "gui.back"]) {
+            let hover = ui::hovered(self.cursor, x, y, 150.0, 20.0);
+            ui::button(
+                batch,
+                atlas,
+                x,
+                y,
+                150.0,
+                20.0,
+                &Text::translate(key, &[]),
+                true,
+                hover,
+            );
+        }
+    }
+    /// WarningScreen's answer: disconnect, or back to Server Links.
+    pub(super) fn dialog_warning_click(&mut self) -> Result<()> {
+        let (w, h) = self.gui_size();
+        let layout = dialog_warning_layout(&self.gui.atlas, (w, h));
+        for (i, (x, y)) in layout.buttons.iter().enumerate() {
+            if !ui::hovered(self.cursor, *x, *y, 150.0, 20.0) {
+                continue;
+            }
+            self.audio.play_button_click();
+            if i == 0 {
+                // DialogConnectionAccess.disconnect: leave with the custom
+                // screens' reason.
+                let reason = self.translate(
+                    "menu.custom_screen_info.disconnect",
+                    "Custom screen rejected",
+                );
+                self.leave_server(Some(reason))?;
+            } else {
+                self.screen = Screen::ServerLinks;
+            }
+            return Ok(());
+        }
+        Ok(())
+    }
+}
+
+/// A confirm screen's laid-out text (title, message, extra warning lines) and
+/// button corners; the whole column centred (ConfirmScreen.init).
+struct ConfirmLayout {
+    lines: Vec<(Text, f32, f32)>,
+    buttons: Vec<(f32, f32)>,
+}
+/// `ConfirmScreen.init`: title, message wrapped to `width - 50` (15 rows at
+/// most), the extra lines, then a button row `spacing` 4 with `paddingTop` 16.
+fn confirm_layout(
+    font: &horizon_client::font::Font,
+    (w, h): (f32, f32),
+    title: &Text,
+    message: &Text,
+    extra: &[Text],
+    button_widths: &[f32],
+) -> ConfirmLayout {
+    let message: Vec<Text> = font
+        .split_lines(message, w - 50.0)
+        .into_iter()
+        .take(15)
+        .map(|(line, _)| line)
+        .collect();
+    // LinearLayout vertical spacing 8; the button row's children pad 16 on top.
+    let extra_h = 17.0 * extra.len() as f32;
+    let mh = 9.0 * message.len() as f32;
+    let total = 9.0 + 8.0 + mh + extra_h + 8.0 + 16.0 + 20.0;
+    let mut y = ((h - total) / 2.0).trunc();
+    let mut lines = Vec::new();
+    let mut push = |line: &Text, at: f32| {
+        let lw = font.width_text(line);
+        lines.push((line.clone(), ((w - lw) / 2.0).trunc(), at));
+    };
+    push(title, y);
+    y += 17.0;
+    for line in &message {
+        push(line, y);
+        y += 9.0;
+    }
+    for line in extra {
+        y += 8.0;
+        push(line, y);
+        y += 9.0;
+    }
+    let row_w: f32 = button_widths.iter().sum::<f32>() + 4.0 * (button_widths.len() - 1) as f32;
+    let by = y + 8.0 + 16.0;
+    let mut bx = ((w - row_w) / 2.0).trunc();
+    let buttons = button_widths
+        .iter()
+        .map(|bw| {
+            let p = (bx, by);
+            bx += bw + 4.0;
+            p
+        })
+        .collect();
+    ConfirmLayout { lines, buttons }
+}
+fn confirm_link_layout(
+    atlas: &horizon_client::hud::HudAtlas,
+    size: (f32, f32),
+    url: &str,
+) -> ConfirmLayout {
+    // ConfirmLinkScreen (untrusted): `chat.link.confirm`, the link as the
+    // message, `chat.link.warning` in its red (0xFFCCCC).
+    confirm_layout(
+        &atlas.font,
+        size,
+        &Text::translate("chat.link.confirm", &[]),
+        &Text::literal(url.to_owned()),
+        &[Text::translate("chat.link.warning", &[]).with_color(0xFFCCCC)],
+        &[100.0; 3],
+    )
+}
+fn dialog_warning_layout(atlas: &horizon_client::hud::HudAtlas, size: (f32, f32)) -> ConfirmLayout {
+    confirm_layout(
+        &atlas.font,
+        size,
+        &Text::translate("menu.custom_screen_info.title", &[]),
+        &Text::translate("menu.custom_screen_info.contents", &[]),
+        &[],
+        &[150.0; 2],
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn untrusted_uris_are_http_or_https_with_a_scheme() {
+        for ok in [
+            "https://example.net/x",
+            "http://example.net",
+            "HTTPS://EXAMPLE.NET",
+        ] {
+            assert!(valid_untrusted_uri(ok), "{ok}");
+        }
+        for bad in [
+            "example.net/no-scheme",
+            "ftp://example.net",
+            "file:///etc/passwd",
+            "javascript:alert(1)",
+            "https://exa mple.net",
+            "://example.net",
+            "",
+        ] {
+            assert!(!valid_untrusted_uri(bad), "{bad}");
+        }
+    }
+}
diff --git a/crates/horizon-client/src/game/server_mods.rs b/crates/horizon-client/src/game/server_mods.rs
index db88639eb..a5a4b0f3f 100644
--- a/crates/horizon-client/src/game/server_mods.rs
+++ b/crates/horizon-client/src/game/server_mods.rs
@@ -47,19 +47,129 @@ impl Game<'_> {
     ) -> bool {
         false
     }
+    pub(super) fn apply_mod_block_writes(&mut self) {}
 }
 
 #[cfg(feature = "mods")]
 mod run {
     use super::{Game, LanHost, ModEvent, Who};
+    use horizon_client::chunk_map::ChunkMap;
     use horizon_client::{
         command::args::GameMode as Mode,
         lan::data::component_nbt,
         text::{self, Text},
     };
-    use horizon_mods::{BlockPos, GameMode, Output, ServerPlayer};
+    use horizon_mods::{
+        ArgumentKind, BlockPos, GameMode, Output, ServerCommand, ServerPlayer, WorldView,
+    };
     use horizon_protocol::packets::play::{self, Clientbound as C};
-    use horizon_world::registry::BlockStateId;
+    use horizon_world::registry::{BlockRegistry, BlockStateId};
+    use serde_json::{Value, json};
+
+    /// Blocks queued for levels that don't tick (another dimension, in-frame)
+    /// are kept up to this many; the oldest go first.
+    const MAX_QUEUED_WRITES: usize = 1 << 16;
+
+    /// Capability `world`'s view during a call: the levels' chunks, moved out
+    /// of the game for the call and back after it (no copy).
+    struct LentWorld {
+        registry: &'static BlockRegistry,
+        biomes: std::sync::Arc<horizon_client::biome::Biomes>,
+        dims: Vec<(&'static str, ChunkMap)>,
+    }
+    impl WorldView for LentWorld {
+        fn block(&self, dimension: &str, x: i32, y: i32, z: i32) -> Option<String> {
+            let (_, chunks) = self.dims.iter().find(|(d, _)| *d == dimension)?;
+            let chunk = chunks.get(&(x >> 4, z >> 4))?;
+            Some(state_string(self.registry, chunk.block(x & 15, y, z & 15)))
+        }
+        fn biome(&self, dimension: &str, x: i32, y: i32, z: i32) -> Option<String> {
+            let (_, chunks) = self.dims.iter().find(|(d, _)| *d == dimension)?;
+            let chunk = chunks.get(&(x >> 4, z >> 4))?;
+            Some(self.biomes.get(chunk.biome(x, y, z)).name.clone())
+        }
+        fn has_dimension(&self, dimension: &str) -> bool {
+            matches!(
+                dimension,
+                "minecraft:overworld" | "minecraft:the_nether" | "minecraft:the_end"
+            )
+        }
+        fn check_state(&self, state: &str) -> Result<(), String> {
+            crate::game::render_control::parse_state(self.registry, state)
+                .map(drop)
+                .map_err(|e| format!("{state}: {e}"))
+        }
+    }
+
+    /// Server mods' commands as a root of the commands report
+    /// (`lan::commands`): a literal per command, then its arguments in a
+    /// chain, each node runnable where only optional arguments follow.
+    fn command_tree<'a>(commands: impl Iterator<Item = &'a ServerCommand>) -> Value {
+        let mut root = serde_json::Map::new();
+        for c in commands {
+            let mut next: Option<(String, Value)> = None;
+            for (i, a) in c.arguments.iter().enumerate().rev() {
+                let executable = c.arguments.get(i + 1).is_none_or(|b| b.optional);
+                let (parser, properties) = match a.kind {
+                    ArgumentKind::Word => ("brigadier:string", json!({"type": "word"})),
+                    ArgumentKind::Text => ("brigadier:string", json!({"type": "greedy"})),
+                    ArgumentKind::Integer((min, max)) => {
+                        let mut p = serde_json::Map::new();
+                        if let Some(min) = min {
+                            p.insert("min".into(), min.into());
+                        }
+                        if let Some(max) = max {
+                            p.insert("max".into(), max.into());
+                        }
+                        ("brigadier:integer", Value::Object(p))
+                    }
+                    ArgumentKind::Number => ("brigadier:double", Value::Null),
+                    ArgumentKind::Boolean => ("brigadier:bool", Value::Null),
+                    ArgumentKind::Player => (
+                        "minecraft:entity",
+                        json!({"amount": "single", "type": "players"}),
+                    ),
+                    ArgumentKind::BlockPos => ("minecraft:block_pos", Value::Null),
+                };
+                let mut node = json!({
+                    "type": "argument",
+                    "parser": parser,
+                    "properties": properties,
+                    "executable": executable,
+                });
+                if let Some((name, child)) = next.take() {
+                    node["children"] = json!({ name: child });
+                }
+                next = Some((a.name.clone(), node));
+            }
+            let executable = c.arguments.first().is_none_or(|a| a.optional);
+            let mut literal = json!({"type": "literal", "executable": executable});
+            if let Some((name, child)) = next {
+                literal["children"] = json!({ name: child });
+            }
+            root.insert(c.name.clone(), literal);
+        }
+        if root.is_empty() {
+            return Value::Null;
+        }
+        json!({"type": "root", "children": root})
+    }
+
+    /// `minecraft:oak_log[axis=y]`.
+    fn state_string(registry: &BlockRegistry, state: BlockStateId) -> String {
+        let Some(s) = registry.state(state) else {
+            return "minecraft:air".into();
+        };
+        if s.properties.is_empty() {
+            return s.name.clone();
+        }
+        let props: Vec<String> = s
+            .properties
+            .iter()
+            .map(|(k, v)| format!("{k}={v}"))
+            .collect();
+        format!("{}[{}]", s.name, props.join(","))
+    }
 
     /// `UUID.toString()`.
     fn uuid_string(u: u128) -> String {
@@ -138,12 +248,14 @@ mod run {
                 // A server has no frames to check its dev mods in.
                 self.reload_dev_mods();
             }
+            self.send_server_mod_commands();
             if !self.mods.server {
                 return;
             }
             let players = self.server_players(None);
             let snapshot = self.mod_snapshot_with(players.clone());
             self.mods.mods.set_snapshot(snapshot);
+            self.lend_world();
             let before = std::mem::take(&mut self.mods.players);
             for p in before
                 .iter()
@@ -197,8 +309,94 @@ mod run {
                 }
             }
             self.mods.mods.server_tick(self.ticks);
+            self.return_world();
             self.mods.players = players;
             self.show_mod_output();
+            self.apply_mod_block_writes();
+        }
+
+        /// Players' command trees list the running server mods' commands
+        /// after vanilla's, whenever they change (or a hub opens).
+        fn send_server_mod_commands(&mut self) {
+            let key = self.mods.mods.generation();
+            let Some(host) = self.lan.as_mut() else {
+                return;
+            };
+            if host.hub.mod_commands_key() == Some(key) {
+                return;
+            }
+            let tree = command_tree(self.mods.mods.server_commands());
+            host.hub.set_mod_commands(key, tree);
+        }
+
+        /// Lends the levels' chunks to capability `world` for the calls up to
+        /// [`Game::return_world`], when a running server mod has it.
+        fn lend_world(&mut self) {
+            if !self.mods.world {
+                return;
+            }
+            let mut dims = vec![(self.dim.id(), std::mem::take(&mut self.world.chunks))];
+            for (dim, chunks) in self.levels.parked_chunks() {
+                dims.push((dim.id(), std::mem::take(chunks)));
+            }
+            let registry = self.pack.assets.registry;
+            let biomes = self.res.biomes().clone();
+            self.mods.mods.lend_world(Box::new(LentWorld {
+                registry,
+                biomes,
+                dims,
+            }));
+        }
+
+        /// Puts back the chunks [`Game::lend_world`] lent.
+        fn return_world(&mut self) {
+            let Some(view) = self.mods.mods.take_world() else {
+                return;
+            };
+            let view: Box<dyn std::any::Any> = view;
+            let Ok(lent) = view.downcast::<LentWorld>() else {
+                return;
+            };
+            let mut dims = lent.dims;
+            if let Some(i) = dims.iter().position(|(d, _)| *d == self.dim.id()) {
+                self.world.chunks = dims.swap_remove(i).1;
+            }
+            for (dim, chunks) in self.levels.parked_chunks() {
+                if let Some(i) = dims.iter().position(|(d, _)| *d == dim.id()) {
+                    *chunks = dims.swap_remove(i).1;
+                }
+            }
+        }
+
+        /// Makes the blocks server mods set in the level in place, in order,
+        /// as `/setblock` does. Those of other dimensions wait for their level.
+        pub(in crate::game) fn apply_mod_block_writes(&mut self) {
+            if self.mods.block_writes.is_empty() {
+                return;
+            }
+            let dim = self.dim.id();
+            let (now, later): (Vec<_>, Vec<_>) = std::mem::take(&mut self.mods.block_writes)
+                .into_iter()
+                .partition(|(d, _)| d == dim);
+            self.mods.block_writes = later;
+            let registry = self.pack.assets.registry;
+            for (_, b) in now {
+                let state = match crate::game::render_control::parse_state(registry, &b.state) {
+                    Ok(state) => state,
+                    Err(e) => {
+                        log::warn!("Horizon: a server mod set {}: {e}", b.state);
+                        continue;
+                    }
+                };
+                if let Err(e) = self.place_state([b.x, b.y, b.z], state, false) {
+                    log::debug!(
+                        "Horizon: a server mod's block at {} {} {}: {e:?}",
+                        b.x,
+                        b.y,
+                        b.z
+                    );
+                }
+            }
         }
 
         /// A player broke (or placed) `state` at `pos`: the player acting now.
@@ -240,8 +438,11 @@ mod run {
             };
             let snapshot = self.mod_snapshot_with(players);
             self.mods.mods.set_snapshot(snapshot);
+            self.lend_world();
             let owned = self.mods.mods.server_command(&me, line);
+            self.return_world();
             self.show_mod_output();
+            self.apply_mod_block_writes();
             owned
         }
 
@@ -266,10 +467,14 @@ mod run {
             };
             let snapshot = self.mod_snapshot_with(players);
             self.mods.mods.set_snapshot(snapshot);
-            if !self.mods.mods.server_command(&me, line) {
+            self.lend_world();
+            let owned = self.mods.mods.server_command(&me, line);
+            self.return_world();
+            if !owned {
                 return false;
             }
             self.route_mod_output(Some(host));
+            self.apply_mod_block_writes();
             true
         }
 
@@ -349,6 +554,21 @@ mod run {
                         self.tell_server_player(host.as_deref_mut(), &p.id, line);
                     }
                 }
+                Output::SetBlocks {
+                    name,
+                    dimension,
+                    blocks,
+                } => {
+                    let queued = &mut self.mods.block_writes;
+                    queued.extend(blocks.into_iter().map(|b| (dimension.clone(), b)));
+                    if queued.len() > MAX_QUEUED_WRITES {
+                        let over = queued.len() - MAX_QUEUED_WRITES;
+                        queued.drain(..over);
+                        log::warn!(
+                            "Horizon: mod {name} set more blocks than wait for their level: {over} dropped"
+                        );
+                    }
+                }
                 _ => {}
             }
         }
diff --git a/crates/horizon-client/src/game/server_packs.rs b/crates/horizon-client/src/game/server_packs.rs
index 58d25de0e..d0769b894 100644
--- a/crates/horizon-client/src/game/server_packs.rs
+++ b/crates/horizon-client/src/game/server_packs.rs
@@ -3,7 +3,7 @@
 //! and `DownloadedPackSource` as `Minecraft` drives it): the prompt, the
 //! server list's setting, downloads into `downloads/`, and a resource reload
 //! with the server's packs on top of the player's own.
-use super::Game;
+use super::{Game, Progress};
 use horizon_client::{
     Result,
     confirm_screen::Confirm,
@@ -82,6 +82,9 @@ pub(super) struct ServerPackState {
     pub(super) active: Vec<packs::Pack>,
     /// The download batches' notifiers, oldest first.
     notifiers: Vec<PackNotifier>,
+    /// A `tick`-asked reload staged on a worker (`LoadingOverlay`): the
+    /// frame draws its progress until `tick_server_packs` applies it.
+    pub(super) reload: Option<PackReload>,
 }
 /// `DownloadedPackSource.createDownloadNotifier`: one batch's progress in its
 /// own `SystemToast`.
@@ -191,6 +194,21 @@ fn saves() -> PathBuf {
     std::env::current_dir().unwrap_or_default().join("saves")
 }
 
+/// `LoadingOverlay`'s stage lines for a pack reload, indexed by `progress`.
+const RELOAD_LINES: [&str; 4] = [
+    "Preparing resources",
+    "Loading assets",
+    "Loading pack tables",
+    "Applying resources",
+];
+/// A pack reload `ServerPacks::tick` asked for: the CPU half runs on a
+/// worker while `progress` feeds the loading screen, then the apply lands
+/// on the render thread.
+pub(super) struct PackReload {
+    pub(super) progress: Progress,
+    handle: std::thread::JoinHandle<std::result::Result<super::packs::StagedPack, String>>,
+}
+
 impl Game<'_> {
     /// `ConnectScreen`: the server's setting decides what its packs do
     /// (`configureForServerControl`); single player's own server takes them
@@ -314,6 +332,7 @@ impl Game<'_> {
         if self.rest_loader.is_some() || self.world_loader.is_some() {
             return;
         }
+        self.drive_pack_reload();
         let finished = self
             .server_packs
             .queue
@@ -328,13 +347,8 @@ impl Game<'_> {
             if !tick.download.is_empty() {
                 self.start_pack_downloads(tick.download);
             }
-            if let Some(mut load) = tick.reload {
-                while let Some(recovery) = {
-                    let ok = self.reload_server_packs(&load);
-                    self.server_packs.packs.reloaded(ok)
-                } {
-                    load = recovery;
-                }
+            if let Some(load) = tick.reload {
+                self.start_pack_reload(&load);
             }
         }
         for (id, status) in self.server_packs.packs.take_replies() {
@@ -379,24 +393,90 @@ impl Game<'_> {
         }
     }
     /// `DownloadedPackSource.startReload`: the packs on top of the player's
-    /// own, then `Minecraft.reloadResourcePacks`. False when a pack has no
-    /// readable `pack.mcmeta` or the reload failed.
-    fn reload_server_packs(&mut self, load: &[(u128, PathBuf)]) -> bool {
-        let packs: Option<Vec<_>> = load
+    /// own, staged on a worker (`Minecraft.reloadResourcePacks` under a
+    /// `LoadingOverlay`); `drive_pack_reload` applies it. A pack with no
+    /// readable `pack.mcmeta` fails the reload at once, as `onFailure`.
+    fn start_pack_reload(&mut self, load: &[(u128, PathBuf)]) {
+        let server: Option<Vec<_>> = load
             .iter()
             .map(|(id, path)| packs::server_pack(*id, path))
             .collect();
-        let Some(packs) = packs else {
+        let Some(server) = server else {
             log::warn!("Horizon: invalid pack metadata in a server pack, ignoring all");
-            return false;
+            self.finish_pack_reload(false);
+            return;
         };
-        self.server_packs.active = packs;
-        match self.reload_selected_packs() {
+        self.server_packs.active = server.clone();
+        // The overlay swallows input until the apply (`LoadingOverlay`):
+        // release what is held so nothing keeps acting while it covers the
+        // frame (`KeyMapping.releaseAll` when a screen opens).
+        self.keys.clear();
+        self.physical_keys.clear();
+        self.left = false;
+        self.right = false;
+        let vanilla = self.vanilla_root();
+        if self.ui.vanilla_root.as_os_str().is_empty() {
+            self.ui.vanilla_root = vanilla.clone();
+        }
+        let (selected, mods, dev_mods) = (
+            self.settings.resource_packs.clone(),
+            self.settings.mods.enabled.clone(),
+            self.options.dev_mods.clone(),
+        );
+        let (assets, res, context) = (
+            self.pack.assets.clone(),
+            self.res.clone(),
+            self.pack.context.clone(),
+        );
+        let (unicode, japanese) = (self.settings.force_unicode, self.settings.japanese_glyphs);
+        let progress = Progress::with(&RELOAD_LINES);
+        let worker = progress.clone();
+        let handle = std::thread::Builder::new()
+            .name("server-pack-reload".into())
+            .spawn(move || {
+                super::packs::stage_pack(
+                    &vanilla, &selected, &server, &mods, &dev_mods, &assets, &res, &context,
+                    unicode, japanese, &worker,
+                )
+                .map_err(|e| e.to_string())
+            });
+        match handle {
+            Ok(handle) => self.server_packs.reload = Some(PackReload { progress, handle }),
+            Err(e) => {
+                log::error!("Horizon: could not start the pack reload worker: {e}");
+                self.finish_pack_reload(false);
+            }
+        }
+    }
+    /// `PackReloadConfig.Callbacks`: applies the staged reload once its
+    /// worker is done; on failure the packs active before reload again.
+    fn drive_pack_reload(&mut self) {
+        let Some(reload) = &self.server_packs.reload else {
+            return;
+        };
+        if !reload.handle.is_finished() {
+            return;
+        }
+        let reload = self.server_packs.reload.take().unwrap();
+        let staged = reload
+            .handle
+            .join()
+            .unwrap_or_else(|_| Err("the pack reload worker panicked".into()));
+        let ok = match staged
+            .and_then(|staged| self.apply_staged_pack(staged).map_err(|e| e.to_string()))
+        {
             Ok(()) => true,
             Err(e) => {
                 log::warn!("Horizon: server resource pack reload failed: {e}");
                 false
             }
+        };
+        self.finish_pack_reload(ok);
+    }
+    /// `ServerPacks::reloaded` and the recovery reload it can ask for.
+    fn finish_pack_reload(&mut self, ok: bool) {
+        if let Some(recovery) = self.server_packs.packs.reloaded(ok) {
+            self.start_pack_reload(&recovery);
         }
     }
 
diff --git a/crates/horizon-client/src/game/shield.rs b/crates/horizon-client/src/game/shield.rs
index c4f7f98d1..a26bc5d75 100644
--- a/crates/horizon-client/src/game/shield.rs
+++ b/crates/horizon-client/src/game/shield.rs
@@ -182,12 +182,17 @@ impl Game<'_> {
             return;
         };
         let (mx, mz) = (m.position.x, m.position.z);
-        let disable = m
-            .extra
-            .main_hand
-            .as_deref()
-            .and_then(|item| self.res.items().get(item))
-            .map_or(0.0, |i| i.disable_blocking_seconds);
+        // LivingEntity.getSecondsToDisableBlocking: the held weapon's value;
+        // Warden overrides it with a flat 5 seconds.
+        let disable = if m.species() == horizon_client::mobs::Species::Warden {
+            5.0
+        } else {
+            m.extra
+                .main_hand
+                .as_deref()
+                .and_then(|item| self.res.items().get(item))
+                .map_or(0.0, |i| i.disable_blocking_seconds)
+        };
         // Ravager.blockedByItem: stunned half the time (the defender pushed
         // apart), else the defender flung away; no roar in progress.
         if m.species() == horizon_client::mobs::Species::Ravager {
diff --git a/crates/horizon-client/src/game/sign_edit.rs b/crates/horizon-client/src/game/sign_edit.rs
index 2d010f1f5..c26314513 100644
--- a/crates/horizon-client/src/game/sign_edit.rs
+++ b/crates/horizon-client/src/game/sign_edit.rs
@@ -5,7 +5,8 @@ use super::{Game, lan::LanHost};
 use horizon_client::{
     containers::BlockEntity,
     hud::{HudBatch, rgba},
-    signs::wood_type,
+    items::ItemStack,
+    signs::{DYE_TEXT, wood_type},
     ui::EditBox,
 };
 use horizon_protocol::packets::play::{self, Clientbound as C, Serverbound as S};
@@ -20,6 +21,9 @@ pub(super) struct SignEditor {
     pub line: usize,
     /// The line being edited (`AbstractSignEditScreen`'s text field).
     edit: EditBox,
+    /// `AbstractSignEditScreen.messages`: the side's lines as edited, sent
+    /// when the editor closes, even if the sign is gone by then.
+    lines: [String; 4],
 }
 
 fn sign_box() -> EditBox {
@@ -31,13 +35,172 @@ fn sign_box() -> EditBox {
 }
 
 impl Game<'_> {
+    /// `SignBlockEntity.getSlotPlayerIsFacing`: whether the player stands in
+    /// front of the sign's text (within 90 degrees of its facing).
+    fn facing_sign_front(&self, pos: (i32, i32, i32)) -> bool {
+        let Some(player) = self.player.as_ref() else {
+            return true;
+        };
+        let state = self.world.block(pos.0, pos.1, pos.2);
+        let Some(state) = self.pack.assets.registry.state(state) else {
+            return true;
+        };
+        let prop = |key: &str| state.properties.get(key).map(String::as_str);
+        // getYRotationDegrees: a wall sign's `Direction.toYRot`, a standing or
+        // ceiling sign's rotation segment.
+        let y_rot = if state.name.contains("_wall_") {
+            match prop("facing") {
+                Some("west") => 90.0,
+                Some("north") => 180.0,
+                Some("east") => 270.0,
+                _ => 0.0,
+            }
+        } else {
+            prop("rotation")
+                .and_then(|r| r.parse::<f32>().ok())
+                .unwrap_or(0.0)
+                * 22.5
+        };
+        // getSignHitboxCenterPosition: only a wall sign's board is off-centre,
+        // against the wall it hangs on.
+        let centre = if state.name.ends_with("_wall_sign") {
+            match y_rot as i32 {
+                90 => (0.9375, 0.5),
+                180 => (0.5, 0.9375),
+                270 => (0.0625, 0.5),
+                _ => (0.5, 0.0625),
+            }
+        } else {
+            (0.5, 0.5)
+        };
+        let xd = player.position.x - (f64::from(pos.0) + centre.0);
+        let zd = player.position.z - (f64::from(pos.2) + centre.1);
+        let player_y_rot = (zd.atan2(xd).to_degrees() - 90.0) as f32;
+        // Mth.degreesDifferenceAbs.
+        let diff = (player_y_rot - y_rot).rem_euclid(360.0);
+        let diff = if diff >= 180.0 { 360.0 - diff } else { diff };
+        diff <= 90.0
+    }
+    /// `SignBlock.useWithoutItem` (the block's `OpenMenu` effect): a waxed
+    /// sign plays the failed-interaction sound; otherwise a player who may
+    /// build edits the side they face.
+    pub(super) fn use_sign_empty_hand(&mut self, pos: [i32; 3]) {
+        let key = (pos[0], pos[1], pos[2]);
+        let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get(&key) else {
+            return;
+        };
+        if sign.waxed {
+            // `getSignInteractionFailedSoundEvent`: a hanging sign has its own.
+            let sound = if sign.hanging {
+                "minecraft:block.hanging_sign.waxed_interact_fail"
+            } else {
+                "minecraft:block.sign.waxed_interact_fail"
+            };
+            self.audio
+                .play(sound, Some(pos.map(|v| f64::from(v) + 0.5)), 1.0, 1.0);
+        } else if self.may_build() {
+            let front = self.facing_sign_front(key);
+            self.open_sign_editor(key, front);
+        }
+    }
+    /// `SignBlock.useItemOn` with a `SignApplicator` in hand (dyes, ink sacs,
+    /// honeycomb): the item changes the side the player faces and is used up.
+    /// Whether it did; a sign it does not apply to goes on to the empty hand.
+    pub(super) fn use_sign_applicator(&mut self, pos: [i32; 3], held: Option<&ItemStack>) -> bool {
+        let Some(stack) = held else {
+            return false;
+        };
+        let key = (pos[0], pos[1], pos[2]);
+        let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get(&key) else {
+            return false;
+        };
+        if sign.waxed || !self.may_build() {
+            return false;
+        }
+        let item = &*stack.item;
+        let dye = if item.ends_with("_dye") {
+            self.res
+                .items()
+                .get(&stack.item)
+                .and_then(|i| i.dye.clone())
+        } else {
+            None
+        };
+        let colour = dye.and_then(|d| DYE_TEXT.iter().position(|(n, _)| *n == d));
+        if !matches!(
+            item,
+            "minecraft:honeycomb" | "minecraft:glow_ink_sac" | "minecraft:ink_sac"
+        ) && colour.is_none()
+        {
+            return false;
+        }
+        let front = self.facing_sign_front(key);
+        let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get_mut(&key) else {
+            return false;
+        };
+        let centre = pos.map(|v| f64::from(v) + 0.5);
+        let sound = if item == "minecraft:honeycomb" {
+            // HoneycombItem.tryApplyToSign: waxes any sign, empty or not.
+            sign.waxed = true;
+            "minecraft:item.honeycomb.wax_on"
+        } else {
+            let side = if front {
+                &mut sign.front
+            } else {
+                &mut sign.back
+            };
+            // SignApplicator.canApplyToSign: the side must have text.
+            if side.is_empty() {
+                return false;
+            }
+            match colour {
+                Some(c) if side.color != c as u8 => {
+                    side.color = c as u8;
+                    "minecraft:item.dye.use"
+                }
+                None if item == "minecraft:glow_ink_sac" && !side.glowing => {
+                    side.glowing = true;
+                    "minecraft:item.glow_ink_sac.use"
+                }
+                None if item == "minecraft:ink_sac" && side.glowing => {
+                    side.glowing = false;
+                    "minecraft:item.ink_sac.use"
+                }
+                _ => return false,
+            }
+        };
+        if item == "minecraft:honeycomb" {
+            self.level_event_at(3003, pos, 0);
+        }
+        self.audio.play(sound, Some(centre), 1.0, 1.0);
+        self.mark_block_entity_updated(key);
+        let state = self.world.block(pos[0], pos[1], pos[2]);
+        self.post_block_game_event(
+            "minecraft:block_change",
+            pos,
+            self.sculk_actor(),
+            Some(state),
+        );
+        self.stats.add("used", &stack.item, 1);
+        self.consume_held();
+        self.trigger_block("minecraft:item_used_on_block", pos, stack);
+        true
+    }
     /// `SignBlock.openTextEdit` for the front side after placement.
     pub(super) fn open_sign_editor(&mut self, pos: (i32, i32, i32), front: bool) {
+        // Minecraft.setScreen: the editor already open is removed first.
+        self.close_sign_editor();
+        let lines = match self.world.block_entities.get(&pos) {
+            Some(BlockEntity::Sign(sign)) if front => sign.front.lines.clone(),
+            Some(BlockEntity::Sign(sign)) => sign.back.lines.clone(),
+            _ => Default::default(),
+        };
         self.sign_edit = Some(SignEditor {
             pos,
             front,
             line: 0,
             edit: sign_box(),
+            lines,
         });
         self.sign_load();
         self.keys.clear();
@@ -50,14 +213,11 @@ impl Game<'_> {
     pub(super) fn close_sign_editor(&mut self) {
         if let Some(edit) = self.sign_edit.take() {
             if self.remote.is_some() {
-                if let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get(&edit.pos) {
-                    let side = if edit.front { &sign.front } else { &sign.back };
-                    self.send(S::SignUpdate(play::SignUpdate {
-                        pos: [edit.pos.0, edit.pos.1, edit.pos.2],
-                        lines: side.lines.clone(),
-                        front: edit.front,
-                    }));
-                }
+                self.send(S::SignUpdate(play::SignUpdate {
+                    pos: [edit.pos.0, edit.pos.1, edit.pos.2],
+                    lines: edit.lines,
+                    front: edit.front,
+                }));
             } else {
                 self.mark_block_entity_updated(edit.pos);
             }
@@ -206,7 +366,8 @@ impl Game<'_> {
             edit.edit.set_value(&text);
         }
     }
-    /// The box's text onto the sign, when it still fits the line.
+    /// The box's text onto the editor's lines and the sign
+    /// (`AbstractSignEditScreen.setMessage`), when it still fits the line.
     fn sign_write(&mut self) {
         let Some(edit) = self.sign_edit.as_ref() else {
             return;
@@ -215,6 +376,9 @@ impl Game<'_> {
         if !self.sign_fits(&value) {
             return;
         }
+        if let Some(edit) = self.sign_edit.as_mut() {
+            edit.lines[line].clone_from(&value);
+        }
         let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get_mut(&pos) else {
             return;
         };
diff --git a/crates/horizon-client/src/game/spawner.rs b/crates/horizon-client/src/game/spawner.rs
index 538cb39e7..a3761cf7a 100644
--- a/crates/horizon-client/src/game/spawner.rs
+++ b/crates/horizon-client/src/game/spawner.rs
@@ -253,12 +253,21 @@ impl Game<'_> {
         self.world.modified.insert((key.0 >> 4, key.2 >> 4));
     }
     /// `LivingEntity.makePoofParticles` (entity event 20) for a mob.
-    fn mob_poof(&mut self, id: u32) {
+    pub(super) fn mob_poof(&mut self, id: u32) {
+        let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
+            return;
+        };
+        let at = m.position;
+        self.lan_entity_event(id as i32, 20, [at.x, at.y, at.z]);
+        self.poof_particles(id);
+    }
+    /// `Mob.handleEntityEvent` 20 (`spawnAnim` on a client): the poof about
+    /// mob `id`.
+    pub(super) fn poof_particles(&mut self, id: u32) {
         let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
             return;
         };
         let (at, w, h) = (m.position, f64::from(m.width()), f64::from(m.height()));
-        self.lan_entity_event(id as i32, 20, [at.x, at.y, at.z]);
         let options = ParticleOptions::simple(ParticleType::Poof);
         for _ in 0..20 {
             let r = self.particles.level_random();
diff --git a/crates/horizon-client/src/game/spill.rs b/crates/horizon-client/src/game/spill.rs
index 7f370507f..b1953596b 100644
--- a/crates/horizon-client/src/game/spill.rs
+++ b/crates/horizon-client/src/game/spill.rs
@@ -171,8 +171,8 @@ pub(super) struct Spawn {
 pub(super) struct Spill {
     pub(super) spawns: Vec<Spawn>,
     /// Experience orbs (`ExperienceOrb.award`): where and how much, each
-    /// having drawn its merge id from the level random.
-    pub(super) orbs: Vec<([f64; 3], u32)>,
+    /// and the merge id it drew from the level random.
+    pub(super) orbs: Vec<([f64; 3], u32, i32)>,
     /// Block entities the behaviour removed, for the game's own follow-ups
     /// (open screens, playing songs).
     pub(super) removed: Vec<([i32; 3], BlockEntity)>,
@@ -342,8 +342,8 @@ impl GameLevel<'_> {
         while amount > 0 {
             let value = removal::orb_value(amount);
             amount -= value;
-            let _merge_id = self.world.random.next_int_bound(40);
-            self.spill.orbs.push((at, value));
+            let merge_id = self.world.random.next_int_bound(40).unwrap_or(0);
+            self.spill.orbs.push((at, value, merge_id));
         }
     }
     /// `BlockEntity.preRemoveSideEffects` and `removeBlockEntity` for the block
@@ -583,8 +583,8 @@ impl Game<'_> {
             let motion = s.motion.unwrap_or_else(new_item_motion);
             self.spawn_item(s.stack, s.pos, motion, s.delay);
         }
-        for (at, value) in spill.orbs {
-            self.add_orb(at, value);
+        for (at, value, merge_id) in spill.orbs {
+            self.award_orb(at, value, merge_id);
         }
         for (pos, entity) in spill.removed {
             let key = (pos[0], pos[1], pos[2]);
diff --git a/crates/horizon-client/src/game/startup_menu.rs b/crates/horizon-client/src/game/startup_menu.rs
index ed5971324..fdeb726ae 100644
--- a/crates/horizon-client/src/game/startup_menu.rs
+++ b/crates/horizon-client/src/game/startup_menu.rs
@@ -546,6 +546,11 @@ impl Loading {
                             (batch.width, batch.height),
                             self.menu.modifiers.shift_key(),
                         );
+                        title.press_rules(
+                            &gui.atlas,
+                            self.menu.cursor,
+                            (batch.width, batch.height),
+                        );
                         self.menu_action(event_loop, action);
                     }
                 }
diff --git a/crates/horizon-client/src/game/stations.rs b/crates/horizon-client/src/game/stations.rs
index 56b19e393..361879d2e 100644
--- a/crates/horizon-client/src/game/stations.rs
+++ b/crates/horizon-client/src/game/stations.rs
@@ -277,6 +277,10 @@ fn argb(c: i32) -> u32 {
     )
 }
 
+/// A text style's `0xRRGGBB` colour from a HUD colour (`rgba`).
+fn rgb_of(rgba: u32) -> u32 {
+    (rgba & 0xFF) << 16 | (rgba >> 8 & 0xFF) << 8 | (rgba >> 16 & 0xFF)
+}
 impl Game<'_> {
     /// `Component.translatable`: the selected language (which `lang` layers
     /// over `en_us`), the caller's English text last.
@@ -713,7 +717,8 @@ impl Game<'_> {
         if let Some(rest) = self.give(stack)
             && let Some(eye) = self.eye_position()
         {
-            self.spawn_item(rest, [eye[0], eye[1] - 0.3, eye[2]], [0.0, 0.1, 0.0], 40);
+            // Inventory.placeItemBackInInventory: `player.drop(stack, false)`.
+            self.throw_from_eyes(rest, eye, false);
         }
     }
     /// `Player.giveExperienceLevels`.
@@ -1689,20 +1694,34 @@ impl Game<'_> {
         &self,
         stack: &ItemStack,
     ) -> Vec<(horizon_client::text::Text, u32)> {
-        let e: &Enchantments = &self.res.stations().enchantments;
-        let props = e.props(&stack.item);
+        self.stack_tooltip_lines(stack, false)
+    }
+    /// `ItemStack.getRarity`'s colour for the name line and a `[name]` link.
+    fn rarity_color(&self, stack: &ItemStack) -> u32 {
+        let props = self.res.stations().enchantments.props(&stack.item);
         let rarity = horizon_client::item_tooltip::rarity(
             stack,
             props.map_or("common", |p| p.rarity.as_str()),
         );
-        let color = match rarity {
+        match rarity {
             "uncommon" => rgba(255, 255, 85, 255),
             "rare" => rgba(85, 255, 255, 255),
             "epic" => rgba(255, 85, 255, 255),
             _ => u32::MAX,
-        };
-        let name = if let Some(n) = stack.custom_name() {
+        }
+    }
+    /// `ItemStack.getHoverName`: the custom name, a written book's title, the
+    /// item name component, else the item's or potion's name.
+    fn stack_hover_name(&self, stack: &ItemStack) -> String {
+        if let Some(n) = stack.custom_name() {
             n.to_owned()
+        } else if let Some(title) = stack
+            .data()
+            .and_then(|d| d.written.as_ref())
+            .map(|w| w.title.as_str())
+            .filter(|t| !t.trim().is_empty())
+        {
+            title.to_owned()
         } else if let Some(n) = stack.item_name() {
             n
         } else if stack.data().is_some_and(|d| d.ominous_banner) {
@@ -1718,16 +1737,47 @@ impl Game<'_> {
                 .unwrap_or_else(|| self.pack.names.display_item(&stack.item))
         } else {
             self.pack.names.display_item(&stack.item)
-        };
+        }
+    }
+    /// `ItemStack.getTooltipLines`. A `nested` stack is a crossbow's
+    /// projectile: `ChargedProjectiles.addProjectileTooltip` takes its details
+    /// without the name, the player and the advanced flag.
+    fn stack_tooltip_lines(
+        &self,
+        stack: &ItemStack,
+        nested: bool,
+    ) -> Vec<(horizon_client::text::Text, u32)> {
+        let e: &Enchantments = &self.res.stations().enchantments;
+        let color = self.rarity_color(stack);
+        let advanced = !nested && self.options_advanced_tooltips();
         let display = horizon_client::item_tooltip::TooltipDisplay::for_stack(stack);
         let mut lines = Vec::new();
-        if display.name_visible(self.screen == Screen::Creative) {
-            lines.push((horizon_client::text::Text::legacy(&name), color));
+        if !nested && display.name_visible(self.screen == Screen::Creative) {
+            // `getStyledHoverName`: a custom name is italic.
+            let name = self.stack_hover_name(stack);
+            let name = if stack.custom_name().is_some() {
+                horizon_client::text::Text::literal(name).italic()
+            } else {
+                horizon_client::text::Text::legacy(&name)
+            };
+            lines.push((name, color));
         }
         let translate = |k: &str| self.pack.names.display_get(k);
         let push = |lines: &mut Vec<(horizon_client::text::Text, u32)>, s: String, c: u32| {
             lines.push((horizon_client::text::Text::legacy(&s), c));
         };
+        let gray = rgba(170, 170, 170, 255);
+        let item_info = self.res.items().get(&stack.item);
+        // InstrumentComponent.addToTooltip.
+        if let Some(text) =
+            horizon_client::item_tooltip::instrument_line(stack, &display, &translate)
+        {
+            push(&mut lines, text, gray);
+        }
+        // Bees.addToTooltip.
+        if let Some(text) = horizon_client::item_tooltip::bees_line(stack, &display, &translate) {
+            push(&mut lines, text, gray);
+        }
         // ItemContainerContents.addToTooltip.
         let hover_name = |s: &ItemStack| {
             s.custom_name()
@@ -1742,6 +1792,70 @@ impl Game<'_> {
                 push(&mut lines, text, u32::MAX);
             }
         }
+        // BannerPatternLayers.addToTooltip: up to six layer names.
+        if display.shows("minecraft:banner_patterns") {
+            for layer in horizon_client::banner::tooltip_layers(stack).iter().take(6) {
+                let key = self.res.stations().banners.layer_key(layer);
+                push(
+                    &mut lines,
+                    self.translate(&key, &key),
+                    rgba(170, 170, 170, 255),
+                );
+            }
+        }
+        // WrittenBookContent.addToTooltip.
+        for text in horizon_client::item_tooltip::written_book_lines(stack, &display, &translate) {
+            push(&mut lines, text, gray);
+        }
+        // ChargedProjectiles.addToTooltip: each run of equal projectiles, then
+        // the projectile's own details indented under it.
+        if display.shows("minecraft:charged_projectiles") {
+            let charged = stack.data().map_or(&[][..], |d| &d.charged[..]);
+            for run in charged.chunk_by(|a, b| a.same_item_same_components(b)) {
+                let projectile = &run[0];
+                let name = self.stack_hover_name(projectile);
+                let line = if run.len() == 1 {
+                    // `getDisplayName`: `[name]` in the rarity colour.
+                    let mut shown = horizon_client::text::Text::literal(format!("[{name}]"))
+                        .with_color(rgb_of(self.rarity_color(projectile)));
+                    if projectile.custom_name().is_some() {
+                        shown = shown.italic();
+                    }
+                    horizon_client::text::format_translation(
+                        &self.translate(
+                            "item.minecraft.crossbow.projectile.single",
+                            "Projectile: %s",
+                        ),
+                        &[shown],
+                    )
+                } else {
+                    horizon_client::text::format_translation(
+                        &self.translate(
+                            "item.minecraft.crossbow.projectile.multiple",
+                            "Projectile: %s x %s",
+                        ),
+                        &[
+                            horizon_client::text::Text::literal(run.len().to_string()),
+                            horizon_client::text::Text::literal(name),
+                        ],
+                    )
+                };
+                lines.push((line, u32::MAX));
+                for (text, c) in self.stack_tooltip_lines(projectile, true) {
+                    // `literal("  ").append(line).withStyle(GRAY)`: the line's
+                    // own colours win over the gray.
+                    let rgb = if c == u32::MAX {
+                        horizon_client::text::GRAY
+                    } else {
+                        rgb_of(c)
+                    };
+                    let indented = horizon_client::text::Text::literal("  ")
+                        .append(text)
+                        .with_color(rgb);
+                    lines.push((indented, u32::MAX));
+                }
+            }
+        }
         // Fireworks / FireworkExplosion.addToTooltip.
         for text in horizon_client::item_tooltip::firework_lines(stack, &translate) {
             push(&mut lines, text, rgba(170, 170, 170, 255));
@@ -1764,6 +1878,17 @@ impl Game<'_> {
                 };
                 push(&mut lines, text, c);
             }
+            // The attribute modifiers of the effects (`When Applied:`).
+            for (text, c) in horizon_client::item_tooltip::potion_modifier_lines(stack, &translate)
+            {
+                push(&mut lines, text, c);
+            }
+        }
+        // JukeboxPlayable.addToTooltip.
+        if let Some(text) =
+            horizon_client::item_tooltip::jukebox_line(stack, item_info, &display, &translate)
+        {
+            push(&mut lines, text, gray);
         }
         if display.shows("minecraft:trim")
             && let Some((material, pattern)) = stack.data().and_then(|d| d.trim.clone())
@@ -1811,16 +1936,12 @@ impl Game<'_> {
                 );
             }
         }
-        // BannerPatternLayers.addToTooltip: up to six layer names.
-        if display.shows("minecraft:banner_patterns") {
-            for layer in horizon_client::banner::tooltip_layers(stack).iter().take(6) {
-                let key = self.res.stations().banners.layer_key(layer);
-                push(
-                    &mut lines,
-                    self.translate(&key, &key),
-                    rgba(170, 170, 170, 255),
-                );
-            }
+        // DyedItemColor.addToTooltip.
+        if let Some((text, italic)) =
+            horizon_client::item_tooltip::dyed_line(stack, &display, advanced, &translate)
+        {
+            let text = horizon_client::text::Text::legacy(&text);
+            lines.push((if italic { text.italic() } else { text }, gray));
         }
         // ItemLore.addToTooltip: after the enchantments, before the attributes
         // (ItemStack.addDetailsToTooltip).
@@ -1829,6 +1950,50 @@ impl Game<'_> {
                 lines.push((text, u32::MAX));
             }
         }
+        if display.shows("minecraft:attribute_modifiers") {
+            // The item's own modifiers, then its enchantments' for each slot
+            // group (`ItemStack.forEachModifier`).
+            let mut modifiers = item_info.map(|i| i.modifiers.clone()).unwrap_or_default();
+            modifiers.extend(e.modifier_rows(stack));
+            let base = |name: &str, default| {
+                self.player
+                    .as_ref()
+                    .and_then(|player| {
+                        let key = player.attributes.key(name)?;
+                        let handle = player.attributes.lookup(Some(&key))?;
+                        player
+                            .attributes
+                            .instance(&handle)
+                            .ok()
+                            .map(|value| value.base_value())
+                    })
+                    .unwrap_or(default)
+            };
+            let player_base = (!nested).then(|| {
+                [
+                    base("minecraft:attack_damage", 1.0),
+                    base(
+                        "minecraft:attack_speed",
+                        horizon_client::attack_strength::BASE_ATTACK_SPEED,
+                    ),
+                ]
+            });
+            for (text, c) in
+                horizon_client::item_tooltip::attribute_lines(&modifiers, player_base, &translate)
+            {
+                push(&mut lines, text, c);
+            }
+        }
+        // ItemStack.UNBREAKABLE_TOOLTIP.
+        if let Some(text) =
+            horizon_client::item_tooltip::unbreakable_line(stack, &display, &translate)
+        {
+            push(&mut lines, text, rgba(85, 85, 255, 255));
+        }
+        // BlockItemStateProperties.addToTooltip.
+        if let Some(text) = horizon_client::item_tooltip::honey_line(stack, &display, &translate) {
+            push(&mut lines, text, gray);
+        }
         // Spawner.appendHoverText: what a spawner or trial spawner item spawns.
         if display.shows("minecraft:block_entity_data")
             && matches!(
@@ -1852,43 +2017,11 @@ impl Game<'_> {
                 }
             }
         }
-        if display.shows("minecraft:attribute_modifiers")
-            && let Some(info) = self.res.items().get(&stack.item)
-        {
-            let base = |name: &str, default| {
-                self.player
-                    .as_ref()
-                    .and_then(|player| {
-                        let key = player.attributes.key(name)?;
-                        let handle = player.attributes.lookup(Some(&key))?;
-                        player
-                            .attributes
-                            .instance(&handle)
-                            .ok()
-                            .map(|value| value.base_value())
-                    })
-                    .unwrap_or(default)
-            };
-            let player_base = [
-                base("minecraft:attack_damage", 1.0),
-                base(
-                    "minecraft:attack_speed",
-                    horizon_client::attack_strength::BASE_ATTACK_SPEED,
-                ),
-            ];
-            for (text, c) in horizon_client::item_tooltip::attribute_lines(
-                &info.modifiers,
-                Some(player_base),
-                &translate,
-            ) {
-                push(&mut lines, text, c);
-            }
-        }
         if display.shows("minecraft:damage")
-            && let Some(info) = self.res.items().get(&stack.item)
+            && let Some(info) = item_info
             && info.max_damage > 0
             && stack.damage > 0
-            && self.options_advanced_tooltips()
+            && advanced
         {
             push(
                 &mut lines,
@@ -1900,8 +2033,23 @@ impl Game<'_> {
                 u32::MAX,
             );
         }
+        // ItemStack.addDetailsToTooltipTail: with advanced tooltips the item id
+        // and how many components the stack has.
+        if advanced {
+            let dark_gray = rgba(85, 85, 85, 255);
+            push(&mut lines, stack.item.to_string(), dark_gray);
+            let count = horizon_client::item_tooltip::component_count(stack, item_info);
+            if count > 0 {
+                let text = self.translate("item.components", "%s component(s)");
+                push(
+                    &mut lines,
+                    text.replacen("%s", &count.to_string(), 1),
+                    dark_gray,
+                );
+            }
+        }
         // ItemStack.OP_NBT_WARNING, for a player with game master permission.
-        if self.ui.registries.permission >= 2 && block_entity_item::op_warning(stack) {
+        if !nested && self.ui.registries.permission >= 2 && block_entity_item::op_warning(stack) {
             for (key, fallback) in [
                 ("item.op_warning.line1", "Warning:"),
                 (
@@ -2104,12 +2252,18 @@ impl Game<'_> {
         batch: &mut HudBatch,
         layout: &horizon_client::bundle::TooltipLayout,
     ) {
-        for (at, stack) in &layout.slots {
+        for (i, (at, stack)) in layout.slots.iter().enumerate() {
+            let selected = layout.selected == Some(i);
+            let sprite = |name: &str| format!("gui/sprites/container/bundle/{name}");
             // Each draw takes the atlas on its own: the item's needs `&mut self`.
             horizon_client::ui::nine_slice(
                 batch,
                 &self.gui.atlas,
-                "gui/sprites/container/bundle/slot_background",
+                &sprite(if selected {
+                    "slot_highlight_back"
+                } else {
+                    "slot_background"
+                }),
                 at[0],
                 at[1],
                 24.0,
@@ -2119,6 +2273,18 @@ impl Game<'_> {
             let stack = stack.clone();
             let [x, y] = *at;
             self.draw_item(batch, &stack, x + 4.0, y + 4.0);
+            if selected {
+                horizon_client::ui::nine_slice(
+                    batch,
+                    &self.gui.atlas,
+                    &sprite("slot_highlight_front"),
+                    x,
+                    y,
+                    24.0,
+                    24.0,
+                    u32::MAX,
+                );
+            }
         }
         let atlas = &self.gui.atlas;
         if let Some((at, hidden)) = layout.overflow {
diff --git a/crates/horizon-client/src/game/stats.rs b/crates/horizon-client/src/game/stats.rs
index 7f64c6bb2..68a574eb1 100644
--- a/crates/horizon-client/src/game/stats.rs
+++ b/crates/horizon-client/src/game/stats.rs
@@ -256,9 +256,8 @@ impl Game<'_> {
             .fluid
             == horizon_client::blocks::Fluid::Water;
         let on_ground = p.ground.on_ground;
-        let (sprinting, flying, gliding, swimming) = (
+        let (sprinting, gliding, swimming) = (
             p.sprinting,
-            p.flying,
             p.fall_flying,
             p.pose == horizon_client::pose::Pose::Swimming,
         );
@@ -272,15 +271,27 @@ impl Game<'_> {
         });
         let s = &mut self.stats;
         match riding {
-            Some(Ok(horizon_client::mobs::Species::Pig)) => s.custom("pig_one_cm", total),
-            Some(Ok(horizon_client::mobs::Species::Strider)) => s.custom("strider_one_cm", total),
-            Some(Ok(sp)) if horizon_client::mobs::equine::is_equine(sp) => {
-                s.custom("horse_one_cm", horizontal)
+            Some(Ok(sp)) => {
+                use horizon_client::mobs::Species;
+                // `checkRidingStatistics`: only these mounts count, the horse
+                // family by the full 3D distance; any other mount nothing.
+                match sp {
+                    Species::Pig => s.custom("pig_one_cm", total),
+                    Species::Strider => s.custom("strider_one_cm", total),
+                    Species::HappyGhast => s.custom("happy_ghast_one_cm", total),
+                    Species::Nautilus | Species::ZombieNautilus => {
+                        s.custom("nautilus_one_cm", total)
+                    }
+                    sp if horizon_client::mobs::equine::is_equine(sp) => {
+                        s.custom("horse_one_cm", total)
+                    }
+                    _ => {}
+                }
             }
-            Some(_) => {
+            Some(Err(())) => {
                 if self.boats.iter().any(|b| Some(b.id) == self.riding) {
                     s.custom("boat_one_cm", total)
-                } else {
+                } else if self.carts.iter().any(|c| Some(c.id) == self.riding) {
                     s.custom("minecart_one_cm", total)
                 }
             }
@@ -300,8 +311,9 @@ impl Game<'_> {
                 }
             }
             None if gliding => s.custom("aviate_one_cm", total),
-            None if flying => s.custom("fly_one_cm", horizontal),
-            None if d.y < 0.0 => s.custom("fall_one_cm", (-d.y * 100.0).round() as i32),
+            // Airborne and not gliding: more than 25 cm sideways per move
+            // (creative flight, or a long jump), not only flying.
+            None if horizontal > 25 => s.custom("fly_one_cm", horizontal),
             None => {}
         }
     }
diff --git a/crates/horizon-client/src/game/storage.rs b/crates/horizon-client/src/game/storage.rs
index 1bcb6a524..81895dba3 100644
--- a/crates/horizon-client/src/game/storage.rs
+++ b/crates/horizon-client/src/game/storage.rs
@@ -3,6 +3,7 @@
 //! player's `PlayerEnderChestContainer`, saved as `EnderItems`).
 use super::Game;
 use horizon_client::{containers::BlockEntity, items::ItemStack, text::Text};
+use horizon_core::random::RandomSource;
 
 pub(super) fn is_shulker_box(name: &str) -> bool {
     name.ends_with("shulker_box")
@@ -33,6 +34,55 @@ impl Game<'_> {
         self.container = Some(key);
         self.ender_open = Some(key);
     }
+    /// The block above `key` is a redstone conductor.
+    fn conductor_above(&self, key: (i32, i32, i32)) -> bool {
+        let above = self.world.block(key.0, key.1 + 1, key.2);
+        self.res.behaviours().facts(above).flags
+            & horizon_world::level::data::state_flags::CONDUCTOR
+            != 0
+    }
+    /// `ChestBlock.isChestBlockedAt`: a redstone conductor above the chest or
+    /// a cat sitting on it.
+    fn chest_blocked_at(&self, key: (i32, i32, i32)) -> bool {
+        if self.conductor_above(key) {
+            return true;
+        }
+        // isCatSittingOnChest: a cat whose box meets the block above.
+        let area = horizon_core::geometry::Aabb::new(
+            horizon_core::geometry::Vec3::new(
+                f64::from(key.0),
+                f64::from(key.1 + 1),
+                f64::from(key.2),
+            ),
+            horizon_core::geometry::Vec3::new(
+                f64::from(key.0 + 1),
+                f64::from(key.1 + 2),
+                f64::from(key.2 + 1),
+            ),
+        );
+        self.mobs.iter().any(|m| {
+            m.species() == horizon_client::mobs::Species::Cat
+                && m.alive()
+                && horizon_client::mobs::tame::cat_sitting(m)
+                && m.bounds().intersects(area)
+        })
+    }
+    /// `ChestBlock.getMenuProvider` (`combine(.., false)`) and
+    /// `EnderChestBlock.useWithoutItem`: a blocked chest, or a double chest
+    /// with either half blocked, opens no menu.
+    pub(super) fn chest_menu_blocked(&self, key: (i32, i32, i32), name: &str) -> bool {
+        match name {
+            "minecraft:chest" | "minecraft:trapped_chest" => {
+                self.chest_blocked_at(key)
+                    || self
+                        .chest_partner(key)
+                        .is_some_and(|(other, _)| self.chest_blocked_at(other))
+            }
+            // The ender chest only looks at the block above (no cat check).
+            "minecraft:ender_chest" => self.conductor_above(key),
+            _ => false,
+        }
+    }
     /// Closing it copies the items back and leaves no block-entity contents.
     pub(super) fn close_ender_chest(&mut self) {
         let Some(key) = self.ender_open.take() else {
@@ -107,6 +157,79 @@ impl Game<'_> {
             );
         paired.then_some((other, kind == "right"))
     }
+    /// The open or close sound of a container block (`ChestBlockEntity.playSound`,
+    /// `BarrelBlockEntity.playSound`, `ShulkerBoxBlockEntity.startOpen`): volume
+    /// 0.5 and pitch 0.9 to 1.0. A double chest sounds once from the middle of
+    /// both halves, a barrel from the face it opens on.
+    pub(super) fn container_sound(&mut self, sound: &str, key: (i32, i32, i32), name: &str) {
+        let mut at = [
+            f64::from(key.0) + 0.5,
+            f64::from(key.1) + 0.5,
+            f64::from(key.2) + 0.5,
+        ];
+        if let Some((other, _)) = self.chest_partner(key) {
+            at[0] = f64::from(key.0 + other.0) / 2.0 + 0.5;
+            at[2] = f64::from(key.2 + other.2) / 2.0 + 0.5;
+        } else if name == "minecraft:barrel"
+            && let Some(state) = self
+                .pack
+                .assets
+                .registry
+                .state(self.world.block(key.0, key.1, key.2))
+            && let Some(facing) = state.properties.get("facing")
+        {
+            let (dx, dy, dz) = match facing.as_str() {
+                "up" => (0.0, 0.5, 0.0),
+                "down" => (0.0, -0.5, 0.0),
+                f => {
+                    let (x, z) = facing_step(f);
+                    (f64::from(x) / 2.0, 0.0, f64::from(z) / 2.0)
+                }
+            };
+            at = [at[0] + dx, at[1] + dy, at[2] + dz];
+        }
+        let pitch = self.world.random.next_float() * 0.1 + 0.9;
+        self.audio.play(sound, Some(at), 0.5, pitch);
+    }
+    /// The open or close sound of the container block at `key`, if it has one.
+    /// Callers play it only when the opener count crosses zero
+    /// (`ContainerOpenersCounter.onOpen` / `onClose`).
+    pub(super) fn container_edge_sound(&mut self, key: (i32, i32, i32), open: bool) {
+        let name = self
+            .res
+            .facts()
+            .get(self.world.block(key.0, key.1, key.2))
+            .name
+            .clone();
+        let sound = if is_shulker_box(&name) {
+            if open {
+                "minecraft:block.shulker_box.open"
+            } else {
+                "minecraft:block.shulker_box.close"
+            }
+        } else if &*name == "minecraft:ender_chest" {
+            if open {
+                "minecraft:block.ender_chest.open"
+            } else {
+                "minecraft:block.ender_chest.close"
+            }
+        } else if name.contains("chest") {
+            if open {
+                "minecraft:block.chest.open"
+            } else {
+                "minecraft:block.chest.close"
+            }
+        } else if &*name == "minecraft:barrel" {
+            if open {
+                "minecraft:block.barrel.open"
+            } else {
+                "minecraft:block.barrel.close"
+            }
+        } else {
+            return;
+        };
+        self.container_sound(sound, key, &name);
+    }
     /// The other half of a double chest at `key`, for neighbour updates.
     pub(super) fn chest_other_half(&self, key: (i32, i32, i32)) -> Option<(i32, i32, i32)> {
         self.chest_partner(key).map(|p| p.0)
diff --git a/crates/horizon-client/src/game/text_displays.rs b/crates/horizon-client/src/game/text_displays.rs
index 45bd64fa7..6812be7bf 100644
--- a/crates/horizon-client/src/game/text_displays.rs
+++ b/crates/horizon-client/src/game/text_displays.rs
@@ -164,11 +164,12 @@ impl Game<'_> {
         } else {
             [self.yaw, self.pitch]
         };
+        let scale = self.view_scale();
         for display in self.text_displays.values_mut() {
             display.last_progress = display.progress(partial as f32);
             let d = display.shown.blend(&display.from, display.last_progress);
             let position = display.previous.lerp(display.position, partial);
-            let range = f64::from(d.view_range) * 64.0 * f64::from(self.settings.entity_distance);
+            let range = f64::from(d.view_range) * 64.0 * scale;
             if position.distance_squared(camera) >= range * range || d.text.is_empty() {
                 continue;
             }
@@ -268,6 +269,8 @@ impl Game<'_> {
                         light,
                         layer: if through { 2 } else { 0 },
                         normal: [0; 4],
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
diff --git a/crates/horizon-client/src/game/titles.rs b/crates/horizon-client/src/game/titles.rs
index cbae1f6b4..9bb000314 100644
--- a/crates/horizon-client/src/game/titles.rs
+++ b/crates/horizon-client/src/game/titles.rs
@@ -21,6 +21,22 @@ impl Game<'_> {
         draws.extend(self.titles.title(w, h, partial, font, background));
         hud_layout::paint(batch, &self.gui.atlas, &draws);
     }
+    /// `Hud.extractSavingIndicator`, under the screens: the option, then the
+    /// fading "Saving world" text.
+    pub(super) fn draw_saving_indicator(&self, batch: &mut HudBatch) {
+        if !self.settings.autosave_indicator {
+            return;
+        }
+        let draws = self.saving_indicator.draw(
+            batch.width as i32,
+            batch.height as i32,
+            self.clock.fraction() as f32,
+            &self.gui.atlas.font,
+            Text::literal(self.translate("menu.savingLevel", "Saving world")),
+            self.settings.text_background(0.0),
+        );
+        hud_layout::paint(batch, &self.gui.atlas, &draws);
+    }
     /// The selected stack as `Hud.tick` compares it for the name highlight.
     fn held_name(&self) -> Option<HeldName> {
         let stack = self.inventory.get(self.selected)?.as_ref()?;
@@ -44,6 +60,12 @@ impl Game<'_> {
     /// The title, action bar and selected-item parts of `Hud.tick`.
     pub(super) fn tick_hud(&mut self) {
         self.titles.tick();
+        // `MinecraftServer.isCurrentlySaving` of single player's server.
+        let saving = self
+            .integrated
+            .as_ref()
+            .map_or(self.autosaving, |server| server.is_saving());
+        self.saving_indicator.tick(saving);
         let held = self.held_name();
         self.tool_highlight
             .tick(held, f64::from(self.settings.notification_display_time));
diff --git a/crates/horizon-client/src/game/tnt.rs b/crates/horizon-client/src/game/tnt.rs
index 6bd2ae956..beaac42cc 100644
--- a/crates/horizon-client/src/game/tnt.rs
+++ b/crates/horizon-client/src/game/tnt.rs
@@ -178,7 +178,9 @@ impl Game<'_> {
                 ];
                 self.tnts.remove(i);
                 count -= 1;
-                self.server_explode(center, 4.0, BlockInteraction::Destroy, false)?;
+                self.with_hive_emptying_blast(|g| {
+                    g.server_explode(center, 4.0, BlockInteraction::Destroy, false)
+                })?;
             } else {
                 i += 1;
             }
@@ -252,7 +254,7 @@ impl Game<'_> {
         }
         let range = super::entity_culling::default_range(
             glam::DVec3::splat(PrimedTnt::SIZE),
-            self.settings.entity_distance,
+            self.view_scale(),
         );
         for t in &self.tnts {
             // EntityRenderer.shouldRender.
@@ -332,6 +334,8 @@ impl Game<'_> {
                         layer: if lit { 5 } else { 0 },
                         color,
                         light: packed,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
diff --git a/crates/horizon-client/src/game/trading.rs b/crates/horizon-client/src/game/trading.rs
index 6986d8baa..0f8723737 100644
--- a/crates/horizon-client/src/game/trading.rs
+++ b/crates/horizon-client/src/game/trading.rs
@@ -245,7 +245,7 @@ impl Game<'_> {
             self.handle_mob_events(events)?;
             return Ok(true);
         }
-        self.stats.custom("talk_to_villager", 1);
+        self.stats.custom("talked_to_villager", 1);
         self.ensure_offers(index);
         let m = &self.mobs[index];
         let trade = m.extra.trade.as_deref().cloned().unwrap_or_default();
@@ -398,18 +398,21 @@ impl Game<'_> {
             .as_ref()
             .and_then(|s| s.merchant.as_ref())
             .and_then(|m| m.mob);
-        let session = self.merchant_apply(session, mob);
+        let (session, traded) = self.merchant_apply(session, mob);
+        self.merchant_traded(mob, &traded);
         if let Some(m) = self.station.as_mut().and_then(|s| s.merchant.as_mut()) {
             m.session = session;
         }
     }
-    /// What a menu click's session did, applied to the world and its mob.
+    /// What a menu click's session did, applied to the world and its mob;
+    /// with the result of each trade made, for `merchant_traded`.
     pub(super) fn merchant_apply(
         &mut self,
         session: Box<merchant::Session>,
         mob: Option<u32>,
-    ) -> Box<merchant::Session> {
+    ) -> (Box<merchant::Session>, Vec<ItemStack>) {
         let mut session = session;
+        let mut traded = Vec::new();
         let events = std::mem::take(&mut session.events);
         let (villager, origin) = (session.villager, session.origin);
         if let Some(m) = mob.and_then(|id| self.mobs.iter_mut().find(|m| m.id == id)) {
@@ -438,11 +441,26 @@ impl Game<'_> {
                     };
                     self.audio.play(sound, Some(origin), 1.0, pitch);
                 }
-                merchant::Event::Traded(_) => self.stats.custom("traded_with_villager", 1),
+                merchant::Event::Traded(index) => {
+                    traded.extend(session.offers.get(index).map(|o| o.result.clone()));
+                }
                 merchant::Event::TradeSound => {}
             }
         }
-        session
+        (session, traded)
+    }
+    /// `MerchantResultSlot.checkTakeAchievements` and `AbstractVillager.notifyTrade`
+    /// for each trade made: the statistic and the `villager_trade` trigger.
+    pub(super) fn merchant_traded(&mut self, mob: Option<u32>, results: &[ItemStack]) {
+        for result in results {
+            self.stats.custom("traded_with_villager", 1);
+            let villager = mob
+                .and_then(|id| self.mobs.iter().find(|m| m.id == id))
+                .map(|m| self.mob_entity(m));
+            if let Some(villager) = villager {
+                self.trigger_trade(&villager, result);
+            }
+        }
     }
     /// `Villager.customServerAiStep`: the TRADE reputation event of the last
     /// trade, a tick later; the prices follow the new reputation.
diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs
index 75b546804..05c23568b 100644
--- a/crates/horizon-client/src/game/trident.rs
+++ b/crates/horizon-client/src/game/trident.rs
@@ -1,17 +1,20 @@
 //! Tridents: `TridentItem.releaseUsing` (throw after 10 ticks, or Riptide in
 //! water or rain) and `ThrownTrident` (arrow flight with 0.99 water inertia,
 //! 8 damage plus Impaling, the reversed bounce off a hit, sticking, Loyalty's
-//! return to the owner, pickup) with `ThrownTridentRenderer`.
+//! return to the owner, pickup) with `ThrownTridentRenderer`, and Channeling's
+//! lightning on a hit (`channeling.json`).
 use super::{Game, view_vector};
 use horizon_client::{
     collisions::SceneCollisions,
+    enchant::EffectContext,
     items::ItemStack,
     mesher::Vertex,
     mobs::{Damage, DamageKind, Who, anim::Poses},
     projectiles::ProjectileWorld,
 };
 use horizon_core::{
-    geometry::{Aabb, Vec3},
+    geometry::{Aabb, Vec3, traverse_blocks},
+    position::BlockPos,
     random::RandomSource,
 };
 
@@ -20,7 +23,7 @@ pub(super) struct ThrownTrident {
     pub id: u32,
     pub(super) stack: ItemStack,
     pub(super) position: Vec3,
-    previous: Vec3,
+    pub(super) previous: Vec3,
     pub(super) velocity: Vec3,
     pub(super) yaw: f32,
     pub(super) pitch: f32,
@@ -33,6 +36,8 @@ pub(super) struct ThrownTrident {
     creative_only: bool,
     /// The entity id a server sent as its owner (the one Loyalty returns it to).
     pub(super) owner: u32,
+    /// The guest that threw it (`Projectile.getOwner`); `None` for the host.
+    guest: Option<u32>,
 }
 impl ThrownTrident {
     /// A trident a server sent (`handleAddEntity`): placed and moved by it.
@@ -53,6 +58,7 @@ impl ThrownTrident {
             returning: 0,
             creative_only: false,
             owner: 0,
+            guest: None,
         }
     }
     /// `ThrownTrident.tick`'s Loyalty return: pulled up and towards the
@@ -172,7 +178,7 @@ impl Game<'_> {
         }
         true
     }
-    fn in_water_or_rain(&self) -> bool {
+    fn in_water_or_rain(&mut self) -> bool {
         let Some(p) = &self.player else { return false };
         let (x, y, z) = (
             p.position.x.floor() as i32,
@@ -181,8 +187,8 @@ impl Game<'_> {
         );
         let water = self.res.facts().get(self.world.block(x, y, z)).fluid
             == horizon_client::blocks::Fluid::Water;
-        let sky = self.world.light(x, y + 1, z) >> 4 == 15;
-        water || (self.world.weather.raining && sky)
+        let (at, top) = (p.position, p.bounds().max_position().y);
+        water || self.in_rain(at, top)
     }
     /// The living entities a spinning player can touch this tick, for
     /// `LivingEntity.checkAutoSpinAttack` (none when not spinning).
@@ -216,6 +222,69 @@ impl Game<'_> {
             p.auto_spin_attack_dmg = 0.0;
         }
     }
+    /// The `summon_entity` and `play_sound` effects of `channeling.json`: in a
+    /// thunderstorm (`weather_check`) a spot that sees the sky (`can_see_sky`)
+    /// gets a lightning bolt and the thunder sound.
+    fn channel_lightning(&mut self, at: [f64; 3]) {
+        // Level.isThundering: the thunder level, in dimensions with weather.
+        if self.dim != super::Dim::Overworld || self.world.weather.levels(1.0).1 <= 0.9 {
+            return;
+        }
+        // BlockAndLightGetter.canSeeSky: full sky light.
+        let (x, y, z) = (
+            at[0].floor() as i32,
+            at[1].floor() as i32,
+            at[2].floor() as i32,
+        );
+        if self.world.light(x, y, z) >> 4 != 15 {
+            return;
+        }
+        self.spawn_bolt(at, false);
+        self.audio
+            .play("minecraft:item.trident.thunder", Some(at), 5.0, 1.0);
+    }
+    /// `minecraft:hit_block` of Channeling (`AbstractArrow.hitBlockEnchantmentEffects`):
+    /// the block the trident's path first hits, if it is a lightning rod, with
+    /// the hit location clamped into the block (`BlockPos.clampLocationWithin`).
+    fn channel_rod_hit(&mut self, from: Vec3, velocity: Vec3) {
+        let to = Vec3::new(
+            from.x + velocity.x,
+            from.y + velocity.y,
+            from.z + velocity.z,
+        );
+        let mut scene = SceneCollisions {
+            world: &self.world,
+            binding: self.collision,
+            subject: None,
+        };
+        // ClipContext.Block.COLLIDER with Fluid.NONE.
+        let hit = traverse_blocks(from, to, 1024, |p: BlockPos| {
+            let state = self.world.block(p.x, p.y, p.z);
+            if self.res.facts().is_air(state) {
+                return None;
+            }
+            let shape = self
+                .collision
+                .collision_shape(&mut scene, state, [p.x, p.y, p.z])
+                .ok()?;
+            shape.clip(from, to, p)
+        });
+        let Some(hit) = hit.ok().flatten() else {
+            return;
+        };
+        let state = self.world.block(hit.block.x, hit.block.y, hit.block.z);
+        if !self.res.facts().get(state).name.ends_with("lightning_rod") {
+            return;
+        }
+        let edge = f64::from(1.0e-5f32);
+        let clamp =
+            |v: f64, origin: i32| v.clamp(f64::from(origin) + edge, f64::from(origin) + 1.0 - edge);
+        self.channel_lightning([
+            clamp(hit.location.x, hit.block.x),
+            clamp(hit.location.y, hit.block.y),
+            clamp(hit.location.z, hit.block.z),
+        ]);
+    }
     /// `TridentItem.releaseUsing`.
     pub(super) fn release_trident(&mut self, ticks: u32) {
         if ticks < 10 {
@@ -233,10 +302,11 @@ impl Game<'_> {
             .as_ref()
             .map(|p| [p.position.x, p.position.y, p.position.z]);
         if riptide > 0 {
-            if !self.in_water_or_rain() {
+            // `isInWaterOrRain() && !isPassenger()`.
+            if !self.in_water_or_rain() || self.riding.is_some() {
                 return;
             }
-            self.damage_held(1);
+            self.hurt_held_without_breaking(1);
             // trident_spin_attack_strength: 1.5 + 0.75 per level above the first.
             let strength = 1.5 + 0.75 * (riptide as f32 - 1.0);
             let d = view_vector(self.yaw, self.pitch);
@@ -257,12 +327,8 @@ impl Game<'_> {
             self.audio.play(&sound, at, 1.0, 1.0);
             return;
         }
-        // hurtWithoutBreaking, then the thrown copy.
-        if !self.creative
-            && let Some(s) = self.held_mut().as_mut()
-        {
-            s.damage += 1;
-        }
+        // hurtWithoutBreaking (Unbreaking applies), then the thrown copy.
+        self.hurt_held_without_breaking(1);
         let thrown = self.held().cloned().unwrap_or(stack);
         if !self.creative {
             *self.held_mut() = None;
@@ -303,11 +369,33 @@ impl Game<'_> {
             returning: 0,
             creative_only: self.creative,
             owner: 0,
+            guest: self.lan_acting,
         });
         self.player_projectile_shot();
         self.audio
             .play("minecraft:item.trident.throw", at, 1.0, 1.0);
     }
+    /// The thrower's `PLAYER_HURT_ENTITY` for a trident hit: run as the
+    /// guest that threw it, and not at all once they have left.
+    fn thrower_hit(
+        &mut self,
+        guest: Option<u32>,
+        victim: &horizon_client::advancements::EntityView,
+        direct: horizon_client::advancements::EntityView,
+        damage: f32,
+    ) {
+        let Some(conn) = guest.filter(|c| self.lan_acting != Some(*c)) else {
+            self.player_hit(victim, "minecraft:trident", Some(direct), damage);
+            return;
+        };
+        let Some(mut host) = self.lan.take() else {
+            return;
+        };
+        self.as_guest(&mut host, conn, |g| {
+            g.player_hit(victim, "minecraft:trident", Some(direct), damage)
+        });
+        self.lan = Some(host);
+    }
     pub(super) fn tick_tridents(&mut self) {
         let Some(eye) = self.eye_position() else {
             return;
@@ -356,15 +444,34 @@ impl Game<'_> {
                     }
                 }
                 if let Some((id, _)) = hit_mob {
-                    let impaling = t.stack.enchantment_level("minecraft:impaling") as f32;
-                    let aquatic = self.mobs.iter().find(|m| m.id == id).is_some_and(|m| {
-                        m.kind.flags.aquatic_swimmer || m.kind.flags.breathes_water
-                    });
-                    let damage = 8.0 + if aquatic { 2.5 * impaling } else { 0.0 };
+                    // ThrownTrident.getDamage: `EnchantmentHelper.modifyDamage` on 8
+                    // (impaling hits `#sensitive_to_impaling`, the aquatic tag).
+                    let victim = self
+                        .mobs
+                        .iter()
+                        .find(|m| m.id == id)
+                        .map(|m| m.kind.id.clone());
+                    let ctx = EffectContext {
+                        this: victim.as_deref(),
+                        attacker: Some("minecraft:player"),
+                        direct_attacker: Some("minecraft:trident"),
+                        is_direct: true,
+                        damage_type: Some("minecraft:trident"),
+                        items: Some(self.res.items()),
+                        ..Default::default()
+                    };
+                    let damage = self.res.stations().enchantments.modify_value(
+                        Some(&t.stack),
+                        "minecraft:damage",
+                        &ctx,
+                        &mut self.world.random,
+                        8.0,
+                    );
                     t.dealt_damage = true;
+                    let mut hurt_at = None;
                     if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
                         let from = Some([t.position.x, t.position.y, t.position.z]);
-                        m.damage(
+                        let hurt = m.damage(
                             damage,
                             Damage {
                                 kind: DamageKind::Arrow,
@@ -372,6 +479,27 @@ impl Game<'_> {
                                 from,
                             },
                         );
+                        if hurt {
+                            hurt_at = Some([m.position.x, m.position.y, m.position.z]);
+                        }
+                    }
+                    // `minecraft:post_attack` of Channeling, on the victim.
+                    if let Some(at) = hurt_at
+                        && t.stack.enchantment_level("minecraft:channeling") > 0
+                    {
+                        self.channel_lightning(at);
+                    }
+                    if hurt_at.is_some()
+                        && let Some(m) = self.mobs.iter().find(|m| m.id == id)
+                    {
+                        // LivingEntity.hurtServer: PLAYER_HURT_ENTITY.
+                        let victim = self.mob_entity(m);
+                        let direct = horizon_client::advancements::EntityView {
+                            kind: "minecraft:trident".into(),
+                            position: [t.position.x, t.position.y, t.position.z],
+                            ..Default::default()
+                        };
+                        self.thrower_hit(t.guest, &victim, direct, damage);
                     }
                     self.audio.play(
                         "minecraft:item.trident.hit",
@@ -392,6 +520,7 @@ impl Game<'_> {
                         subject: None,
                     };
                     if let Ok(moved) = scene.resolve(bounds(t.position), t.velocity, 0.0, false) {
+                        let (from, flight) = (t.position, t.velocity);
                         let blocked = (moved.x - t.velocity.x).abs() > 1e-7
                             || (moved.y - t.velocity.y).abs() > 1e-7
                             || (moved.z - t.velocity.z).abs() > 1e-7;
@@ -401,6 +530,9 @@ impl Game<'_> {
                             t.position.z + moved.z,
                         );
                         if blocked {
+                            if t.stack.enchantment_level("minecraft:channeling") > 0 {
+                                self.channel_rod_hit(from, flight);
+                            }
                             t.in_ground = true;
                             t.velocity = Vec3::ZERO;
                             self.audio.play(
@@ -470,7 +602,7 @@ impl Game<'_> {
         let range = 10.0
             * super::entity_culling::default_range(
                 glam::DVec3::splat(2.0 * HALF),
-                self.settings.entity_distance,
+                self.view_scale(),
             );
         for t in &self.tridents {
             // EntityRenderer.shouldRender; ThrownTridentRenderer grows the box by 1.5.
diff --git a/crates/horizon-client/src/game/tweaks.rs b/crates/horizon-client/src/game/tweaks.rs
index cec83e248..648073874 100644
--- a/crates/horizon-client/src/game/tweaks.rs
+++ b/crates/horizon-client/src/game/tweaks.rs
@@ -70,8 +70,7 @@ impl Game<'_> {
     /// One ordinary click on a game slot. False when nothing took it.
     pub(super) fn tweak_click(&mut self, slot: usize, button: i32, input: Input) -> bool {
         if self.remote.is_some() {
-            let ordinal = super::remote::input_ordinal(input);
-            return self.remote_slot_click(slot, button as i8, ordinal);
+            return self.remote_menu_ops(&[(Some(slot), button, input)]);
         }
         if !self.menu_click(Some(slot), button, input) {
             return false;
diff --git a/crates/horizon-client/src/game/vault.rs b/crates/horizon-client/src/game/vault.rs
index f3edfddb3..18430daf6 100644
--- a/crates/horizon-client/src/game/vault.rs
+++ b/crates/horizon-client/src/game/vault.rs
@@ -169,6 +169,8 @@ impl Game<'_> {
                 self.consume_held();
             }
         }
+        // ServerPlayerGameMode.useItemOn: the action was consumed.
+        self.trigger_block("minecraft:item_used_on_block", pos, &stack);
         Ok(true)
     }
     fn vault_events(&mut self, key: Pos, events: Vec<VaultEvent>) -> Result<()> {
diff --git a/crates/horizon-client/src/game/villagers.rs b/crates/horizon-client/src/game/villagers.rs
index 3cfe8aa1d..36c79f893 100644
--- a/crates/horizon-client/src/game/villagers.rs
+++ b/crates/horizon-client/src/game/villagers.rs
@@ -21,6 +21,38 @@ impl Game<'_> {
     fn item_max_stack(&self, item: &str) -> u32 {
         self.res.items().get(item).map_or(64, |i| i.max_stack)
     }
+    /// `WorkAtComposter.useWorkstation`: at a composter the farmer makes
+    /// bread, then composts seeds.
+    pub(super) fn villager_work_at_composter(&mut self, id: u32, pos: [i32; 3]) {
+        let Some(i) = self.villager_index(id) else {
+            return;
+        };
+        if self.composter_level(pos).is_none() {
+            return;
+        }
+        self.villager_make_bread(i);
+        self.villager_compost_items(i, pos);
+    }
+    /// `WorkAtComposter.makeBread`: up to three loaves from nine wheat while
+    /// the villager holds at most 36 bread; what does not fit drops.
+    fn villager_make_bread(&mut self, i: usize) {
+        let max_stack = self.item_max_stack("minecraft:bread");
+        let e = villager::ext_mut(&mut self.mobs[i]);
+        if e.count_item("minecraft:bread") > 36 {
+            return;
+        }
+        let loaves = (e.count_item("minecraft:wheat") / 3).min(3);
+        if loaves == 0 {
+            return;
+        }
+        e.remove_item("minecraft:wheat", loaves * 3);
+        let left = e.add_item(ItemStack::new("minecraft:bread", loaves), max_stack);
+        if let Some(rest) = left {
+            // spawnAtLocation(level, stack, 0.5F)
+            let p = self.mobs[i].position;
+            self.spawn_item(rest, [p.x, p.y + 0.5, p.z], [0.0, 0.2, 0.0], 10);
+        }
+    }
     /// `BehaviorUtils.throwItem`: toss a stack from a villager's hand toward
     /// a point.
     fn villager_throw(&mut self, from: Vec3, eye: f64, to: Vec3, stack: ItemStack) {
@@ -116,7 +148,7 @@ impl Game<'_> {
             // VillagerMakeLove: entity event 13 for the partner, then the parent.
             for i in [ib, ia] {
                 let id = self.mobs[i].id;
-                self.villager_particles(id, "angry_villager");
+                self.mob_event_particles(id, 13);
             }
             return;
         };
@@ -141,12 +173,31 @@ impl Game<'_> {
             child.extra.bed = Some(bed);
         }
         // VillagerMakeLove.giveBirth: entity event 12 for the child.
-        self.villager_particles(id, "heart");
+        self.mob_event_particles(id, 12);
     }
-    /// `Villager.handleEntityEvent` 12, 13, 14 and 42:
-    /// `AbstractVillager.addParticlesAroundSelf`.
-    pub(super) fn villager_particles(&mut self, id: u32, kind: &'static str) {
-        self.particles_around_mob(id, kind, horizon_client::particles::Burst::VILLAGER);
+    /// `Level.broadcastEntityEvent` of an event whose `handleEntityEvent`
+    /// draws particles about the mob (villager 12, 13 and 14, taming 6 and 7,
+    /// love 18): the guests get the byte, and this game draws it as its own
+    /// client would.
+    pub(super) fn mob_event_particles(&mut self, id: u32, event: i8) {
+        let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
+            return;
+        };
+        let at = [m.position.x, m.position.y, m.position.z];
+        self.lan_entity_event(id as i32, event, at);
+        self.entity_event_particles(id, event);
+    }
+    /// `handleEntityEvent(event)`'s particles about mob `id`
+    /// (`Villager`, `TamableAnimal`, `AbstractHorse`, `Animal`, `Allay`).
+    pub(super) fn entity_event_particles(&mut self, id: u32, event: i8) {
+        let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
+            return;
+        };
+        if let Some((kind, burst)) =
+            horizon_client::particles::entity_event_burst(&m.kind.id, event as u8)
+        {
+            self.particles_around_mob(id, kind, burst);
+        }
     }
     /// `particles::around_self` about mob `id`.
     pub(super) fn particles_around_mob(
@@ -283,7 +334,7 @@ impl Game<'_> {
         }
         // Villager.setLastHurtByMob: entity event 13.
         for id in angry {
-            self.villager_particles(id, "angry_villager");
+            self.mob_event_particles(id, 13);
         }
     }
     /// `Villager.tellWitnessesThatIWasMurdered`: the villagers that saw a
@@ -338,7 +389,7 @@ impl Game<'_> {
             gossip::REPUTATION_CHANGE_PER_TRADE,
         );
         // Villager.customServerAiStep after a trade: entity event 14.
-        self.villager_particles(id, "happy_villager");
+        self.mob_event_particles(id, 14);
     }
     /// `Villager.getPlayerReputation` of the local player.
     pub(super) fn villager_reputation(&self, id: u32) -> i32 {
diff --git a/crates/horizon-client/src/game/wind.rs b/crates/horizon-client/src/game/wind.rs
index fb24102ba..63ac2641d 100644
--- a/crates/horizon-client/src/game/wind.rs
+++ b/crates/horizon-client/src/game/wind.rs
@@ -68,7 +68,7 @@ impl Game<'_> {
             velocity,
             on_ground,
         );
-        self.creatures.projectiles.push(proj);
+        self.add_projectile(proj);
         let pitch = 0.4 / (self.world.random.next_float() * 0.4 + 0.8);
         self.audio
             .play("minecraft:entity.wind_charge.throw", Some(eye), 0.5, pitch);
diff --git a/crates/horizon-client/src/game/wither.rs b/crates/horizon-client/src/game/wither.rs
index 8084425ca..5f01633b0 100644
--- a/crates/horizon-client/src/game/wither.rs
+++ b/crates/horizon-client/src/game/wither.rs
@@ -2,11 +2,53 @@
 //! its boss bar, and its skulls hitting and exploding.
 use super::Game;
 use horizon_client::{
+    items::ItemStack,
     mobs::{Damage, DamageKind, Species, Who},
     projectiles::{Projectile, ProjectileKind},
 };
+use horizon_core::position::BlockPos;
 
 impl Game<'_> {
+    /// `LivingEntity.createWitherRose`: a mob a wither killed leaves a wither
+    /// rose where it stood (with mobGriefing, on air that can hold it), else
+    /// drops one.
+    pub(super) fn create_wither_rose(&mut self, m: &horizon_client::mobs::Mob) {
+        // getKillCredit: the player who last hurt it, else the last mob (kept
+        // for 100 ticks).
+        let by_wither = m.ai.last_hurt_by_player <= 0
+            && m.age as i32 - m.ai.last_hurt_by_time <= 100
+            && matches!(m.ai.last_hurt_by, Some(Who::Mob(id))
+                if self.mobs.iter().any(|o| o.id == id && o.alive() && o.species() == Species::Wither));
+        if !by_wither {
+            return;
+        }
+        let pos = [
+            m.position.x.floor() as i32,
+            m.position.y.floor() as i32,
+            m.position.z.floor() as i32,
+        ];
+        let registry = self.pack.assets.registry;
+        let rose = registry.default_state("minecraft:wither_rose");
+        if self.ui.rules.bool("mob_griefing")
+            && let Some(rose) = rose
+            && self
+                .res
+                .facts()
+                .is_air(self.world.block(pos[0], pos[1], pos[2]))
+            && self.with_level(|b, level, ticks| {
+                b.can_survive(level, ticks, BlockPos::new(pos[0], pos[1], pos[2]), rose)
+            })
+        {
+            let _ = self.level_set(pos, rose);
+            return;
+        }
+        self.spawn_item(
+            ItemStack::new("minecraft:wither_rose", 1),
+            [m.position.x, m.position.y, m.position.z],
+            super::dispenser::new_item_motion(),
+            0,
+        );
+    }
     fn is_wither_skull(&self, p: [i32; 3]) -> bool {
         let name = &*self
             .res
@@ -130,7 +172,10 @@ impl Game<'_> {
         if let Some(id) = owner {
             self.note_attacker("minecraft:explosion", id);
         }
-        self.explode(at, 1.0)
+        self.combat.explosion_owner = owner;
+        let result = self.with_hive_emptying_blast(|g| g.explode(at, 1.0));
+        self.combat.explosion_owner = None;
+        result
     }
 }
 /// Wither skulls drawn as the skull model, blue when dangerous.
diff --git a/crates/horizon-client/src/game/world_loading.rs b/crates/horizon-client/src/game/world_loading.rs
index ef47cc9c0..d7c4f2b03 100644
--- a/crates/horizon-client/src/game/world_loading.rs
+++ b/crates/horizon-client/src/game/world_loading.rs
@@ -46,6 +46,10 @@ impl WorldRequest {
         options: &Options,
         settings: &Settings,
     ) -> Result<PreparedWorld> {
+        // Before any chunk is read: a loaded container with a loot table is rolled as its chunk
+        // is decoded (`save::roll_loaded_loot`), and the spawn chunks are read while the world
+        // opens. Every world opens here: in-frame, on the server thread, on a dedicated server.
+        horizon_client::structure_blocks::loot_data(&options.resources);
         let Self {
             save_root,
             folder,
@@ -89,7 +93,14 @@ impl WorldRequest {
             level.hardcore = o.hardcore;
             level.difficulty = horizon_client::title::DIFFICULTIES[o.difficulty()].into();
             level.allow_commands = Some(o.commands(creative));
-            horizon_client::save::write_world_gen_settings(&save_root, level.seed, o.world_gen())?;
+            horizon_client::save::write_world_gen_settings_with(
+                &save_root,
+                level.seed,
+                o.world_gen(),
+                o.flat_settings(),
+            )?;
+            // WorldCreationUiState.getGameRules, written with the level.
+            level.game_rules = o.rules.by_name();
         }
         // Worlds made without the Create New World screen (--world, the
         // control socket) take its default: commands on for Creative only.
@@ -192,6 +203,82 @@ impl WorldLoader {
     }
 }
 
+/// How long the preloaded world data outlives the world screens: a player
+/// who goes back to the title or to Multiplayer and opens no world for this
+/// long gets the memory back.
+const PRELOAD_KEPT: std::time::Duration = std::time::Duration::from_secs(60);
+
+enum Preload {
+    Idle,
+    /// Read, or being read, on the "World data preload" thread. `left`: when
+    /// the player last left the world screens.
+    Started {
+        thread: std::thread::JoinHandle<()>,
+        left: Option<std::time::Instant>,
+    },
+    /// A world opened: the data is the world's now, and stays.
+    Used,
+}
+
+static PRELOAD: std::sync::Mutex<Preload> = std::sync::Mutex::new(Preload::Idle);
+
+/// Each frame of the title: read what every world opening loads and keeps
+/// for the rest of the process (the worldgen bundle, the loot tables and the
+/// registries the server sends) on a helper thread while the player is on the
+/// world screens (`on_world_screens`: Singleplayer, Create World and their
+/// dialogs), so it overlaps the time spent choosing a world. A world opened
+/// meanwhile waits for the part being read instead of reading it again. Not
+/// at the title screen itself: many players only go to Multiplayer, and
+/// small machines need the memory. Dropped after `PRELOAD_KEPT` away from
+/// the world screens without a world opening.
+pub(super) fn preload_world_data(
+    on_world_screens: bool,
+    resources: &std::path::Path,
+    registry: &'static horizon_world::registry::BlockRegistry,
+) {
+    let mut preload = PRELOAD.lock().unwrap_or_else(|e| e.into_inner());
+    match &mut *preload {
+        Preload::Used => {}
+        Preload::Idle if on_world_screens => {
+            let resources = resources.to_owned();
+            let spawned = std::thread::Builder::new()
+                .name("World data preload".into())
+                .spawn(move || {
+                    horizon_threads::behind_server();
+                    // Errors are left for the world opening to report.
+                    let _ = horizon_client::vanillagen::shared_data(
+                        &resources.join("worldgen"),
+                        registry,
+                    );
+                    let _ = horizon_client::structure_blocks::loot_data(&resources);
+                    let _ = super::lan::sync_data(&resources);
+                });
+            match spawned {
+                Ok(thread) => *preload = Preload::Started { thread, left: None },
+                Err(e) => log::warn!("Horizon: world data preload: {e}"),
+            }
+        }
+        Preload::Idle => {}
+        Preload::Started { left, .. } if on_world_screens => *left = None,
+        Preload::Started { thread, left } => {
+            let left = *left.get_or_insert_with(std::time::Instant::now);
+            if left.elapsed() >= PRELOAD_KEPT && thread.is_finished() {
+                horizon_client::vanillagen::forget_shared_data();
+                horizon_client::structure_blocks::forget_loot_data();
+                super::lan::forget_sync_data();
+                horizon_threads::release_free_memory();
+                *preload = Preload::Idle;
+                log::info!("Horizon: preloaded world data dropped, no world opened");
+            }
+        }
+    }
+}
+
+/// A world opens: what `preload_world_data` read is the world's from now on.
+pub(super) fn world_data_used() {
+    *PRELOAD.lock().unwrap_or_else(|e| e.into_inner()) = Preload::Used;
+}
+
 pub(super) fn make_streaming(
     res: &Resources,
     pack: &PackResources,
diff --git a/crates/horizon-client/src/game/zombie_reinforcements.rs b/crates/horizon-client/src/game/zombie_reinforcements.rs
new file mode 100644
index 000000000..4c6100f43
--- /dev/null
+++ b/crates/horizon-client/src/game/zombie_reinforcements.rs
@@ -0,0 +1,134 @@
+//! `Zombie.hurtServer`'s reinforcements: a hurt zombie on Hard may call
+//! another of its kind from 7 to 40 blocks away to fight its target.
+use super::Game;
+use horizon_client::mobs::{
+    MobType, Species, Who,
+    finalize::{self, Attr, Op},
+    spawn_rules::{self, Reason},
+    spawn_selection::{self, NaturalLevel},
+    spawner::SpawnerLevel,
+};
+use horizon_core::random::{LegacyRandom, RandomSource};
+use horizon_world::food::Difficulty;
+
+/// `Zombie.REINFORCEMENT_ATTEMPTS`.
+const ATTEMPTS: usize = 50;
+/// `Zombie.REINFORCEMENT_RANGE_MIN` and `REINFORCEMENT_RANGE_MAX`.
+const RANGE_MIN: i32 = 7;
+const RANGE_MAX: i32 = 40;
+
+/// One axis of the offset: `Mth.nextInt(random, 7, 40) * Mth.nextInt(random, -1, 1)`.
+fn offset(random: &mut LegacyRandom) -> i32 {
+    let distance = random
+        .next_int_between_inclusive(RANGE_MIN, RANGE_MAX)
+        .unwrap_or(RANGE_MIN);
+    distance * random.next_int_between_inclusive(-1, 1).unwrap_or(0)
+}
+
+impl Game<'_> {
+    /// `Zombie.hurtServer` after the hit: on Hard, with the zombie's chance
+    /// and monsters spawning, a copy of it appears out of sight and takes
+    /// `target`; both then call less often.
+    pub(super) fn call_reinforcements(&mut self, caller: u32, target: Who) {
+        let Some(index) = self.mobs.iter().position(|m| m.id == caller) else {
+            return;
+        };
+        if self.world.health_rules.difficulty != Difficulty::Hard {
+            return;
+        }
+        let zombie = &mut self.mobs[index];
+        if f64::from(zombie.random.next_float()) >= zombie.attrs.spawn_reinforcements {
+            return;
+        }
+        // ServerLevel.isSpawningMonsters.
+        if !self.ui.rules.bool("spawn_mobs") || !self.ui.rules.bool("spawn_monsters") {
+            return;
+        }
+        let kind = zombie.kind.clone();
+        let from = [
+            zombie.position.x.floor() as i32,
+            zombie.position.y.floor() as i32,
+            zombie.position.z.floor() as i32,
+        ];
+        let mut own = std::mem::replace(&mut zombie.random, LegacyRandom::new(0));
+        let mut rules = std::mem::replace(&mut self.world.random, LegacyRandom::new(0));
+        let spot = self.reinforcement_spot(&kind, from, &mut own, &mut rules);
+        self.mobs[index].random = own;
+        self.world.random = rules;
+        let Some(spot) = spot else {
+            return;
+        };
+        let Some(id) = self.spawn_mob(&kind.id, spot.map(f64::from), false) else {
+            return;
+        };
+        if let Some(reinforcement) = self.mobs.iter_mut().find(|m| m.id == id) {
+            reinforcement.ai.target = Some(target);
+            // ZOMBIE_REINFORCEMENT_CALLEE_CHARGE.
+            finalize::add_modifier(
+                reinforcement,
+                Attr::SpawnReinforcements,
+                "minecraft:reinforcement_callee_charge",
+                -f64::from(0.05f32),
+                Op::AddValue,
+            );
+        }
+        // The caller's charge grows by 0.05 each time it calls.
+        let caller = &mut self.mobs[index];
+        let charged = finalize::modifier_amount(
+            caller,
+            Attr::SpawnReinforcements,
+            "minecraft:reinforcement_caller_charge",
+        )
+        .unwrap_or(0.0);
+        finalize::add_modifier(
+            caller,
+            Attr::SpawnReinforcements,
+            "minecraft:reinforcement_caller_charge",
+            charged - 0.05,
+            Op::AddValue,
+        );
+    }
+    /// The block `Zombie.hurtServer` puts the reinforcement at: the first of
+    /// 50 random offsets with a valid spawn surface, no alive player within
+    /// 7 blocks, and room for the zombie standing on the block's corner.
+    fn reinforcement_spot(
+        &self,
+        kind: &MobType,
+        from: [i32; 3],
+        own: &mut LegacyRandom,
+        rules: &mut LegacyRandom,
+    ) -> Option<[i32; 3]> {
+        let level = self.natural_level();
+        let (width, height) = (kind.width as f32, kind.height as f32);
+        for _ in 0..ATTEMPTS {
+            let [x, y, z] = from.map(|v| v + offset(own));
+            if !spawn_rules::is_spawn_position_ok(kind.species, &level, x, y, z)
+                || !spawn_rules::check_spawn_rules(
+                    kind.species,
+                    &level,
+                    Reason::Reinforcement,
+                    rules,
+                    x,
+                    y,
+                    z,
+                )
+            {
+                continue;
+            }
+            // setPos(x, y, z): the box is centred on the block's corner.
+            let bounds =
+                spawn_selection::spawn_box(f64::from(x), f64::from(y), f64::from(z), width, height);
+            // Drowned.canSpawnInLiquids.
+            let wet_ok = kind.species == Species::Drowned
+                || !spawn_selection::contains_any_liquid(&level, bounds);
+            if !level.alive_player_near(f64::from(x), f64::from(y), f64::from(z), 7.0)
+                && level.unobstructed(bounds)
+                && level.no_collision(bounds)
+                && wet_ok
+            {
+                return Some([x, y, z]);
+            }
+        }
+        None
+    }
+}
diff --git a/crates/horizon-client/src/game/game_rules_screen.rs b/crates/horizon-client/src/game_rules_screen.rs
similarity index 91%
rename from crates/horizon-client/src/game/game_rules_screen.rs
rename to crates/horizon-client/src/game_rules_screen.rs
index 0992f7689..7f7c307b6 100644
--- a/crates/horizon-client/src/game/game_rules_screen.rs
+++ b/crates/horizon-client/src/game_rules_screen.rs
@@ -1,8 +1,9 @@
-//! InWorldGameRulesScreen (AbstractGameRulesScreen), opened from World
-//! Options: the rules by category under a search box, a switch or a number
-//! box each, and Done sending the changed ones (ServerboundSetGameRulePacket).
-//! Leaving with changes asks first (ConfirmScreen).
-use horizon_client::{
+//! AbstractGameRulesScreen: the rules by category under a search box, a
+//! switch or a number box each. InWorldGameRulesScreen, opened from World
+//! Options, sends the changed ones on Done (ServerboundSetGameRulePacket) and
+//! asks before leaving with changes (ConfirmScreen); WorldCreationGameRulesScreen,
+//! opened from Create New World, hands them back and leaves without asking.
+use crate::{
     confirm_screen::Confirm,
     font::Font,
     gamerules::{self, GameRules, RULES, Rule, Value},
@@ -32,14 +33,14 @@ enum Row {
 
 /// What a click or Escape asks of World Options.
 #[derive(Debug, PartialEq)]
-pub(super) enum Exit {
+pub enum Exit {
     /// Done: the rules that changed.
     Apply(Vec<(&'static str, Value)>),
     /// Cancel, or discarding the changes.
     Discard,
 }
 
-pub(super) struct RulesScreen {
+pub struct RulesScreen {
     search: EditBox,
     values: GameRules,
     initial: GameRules,
@@ -49,6 +50,8 @@ pub(super) struct RulesScreen {
     scroll: ui::Scroll,
     /// ConfirmScreen "Game Rule Changes" in its place.
     confirm: bool,
+    /// InWorldGameRulesScreen rather than WorldCreationGameRulesScreen.
+    in_world: bool,
 }
 
 fn name_key(r: &Rule) -> String {
@@ -102,7 +105,15 @@ fn confirm(font: &Font, size: (f32, f32)) -> Confirm {
 }
 
 impl RulesScreen {
-    pub(super) fn new(rules: &GameRules) -> Self {
+    /// InWorldGameRulesScreen over the world's rules.
+    pub fn new(rules: &GameRules) -> Self {
+        Self::build(rules, true)
+    }
+    /// WorldCreationGameRulesScreen over the new world's rules.
+    pub fn for_creation(rules: &GameRules) -> Self {
+        Self::build(rules, false)
+    }
+    fn build(rules: &GameRules, in_world: bool) -> Self {
         // setInitialFocus: the search box.
         let search = EditBox::new(0.0, 0.0, SEARCH_WIDTH, 15.0);
         let numbers = RULES
@@ -123,6 +134,7 @@ impl RulesScreen {
             numbers,
             scroll: ui::Scroll::default(),
             confirm: false,
+            in_world,
         }
     }
 
@@ -197,9 +209,10 @@ impl RulesScreen {
             })
             .collect()
     }
-    /// InWorldGameRulesScreen.onClose: pending changes ask first.
+    /// InWorldGameRulesScreen.onClose: pending changes ask first;
+    /// WorldCreationGameRulesScreen.onClose discards them.
     fn close(&mut self) -> Option<Exit> {
-        if self.changes().is_empty() {
+        if !self.in_world || self.changes().is_empty() {
             Some(Exit::Discard)
         } else {
             self.confirm = true;
@@ -207,7 +220,7 @@ impl RulesScreen {
         }
     }
     /// Escape: ConfirmScreen answers no; the rules close.
-    pub(super) fn escape(&mut self) -> Option<Exit> {
+    pub fn escape(&mut self) -> Option<Exit> {
         if self.confirm {
             self.confirm = false;
             None
@@ -216,7 +229,7 @@ impl RulesScreen {
         }
     }
     /// The mouse wheel (AbstractSelectionList: half an entry a step).
-    pub(super) fn wheel(&mut self, delta: f32, h: f32) {
+    pub fn wheel(&mut self, delta: f32, h: f32) {
         if !self.confirm {
             let content = self.content();
             self.scroll
@@ -224,20 +237,20 @@ impl RulesScreen {
         }
     }
     /// A press on the scrollbar holds it (AbstractSelectionList.updateScrolling).
-    pub(super) fn press_scrollbar(&mut self, cursor: (f32, f32), (w, h): (f32, f32)) -> bool {
+    pub fn press_scrollbar(&mut self, cursor: (f32, f32), (w, h): (f32, f32)) -> bool {
         let content = self.content();
         self.scroll
             .press(cursor, Self::bar(w), HEADER, h - FOOTER, content)
     }
     /// The pointer moved while the scrollbar is held.
-    pub(super) fn drag(&mut self, y: f32, h: f32) {
+    pub fn drag(&mut self, y: f32, h: f32) {
         if self.scroll.held() {
             let content = self.content();
             self.scroll.drag(y, HEADER, h - FOOTER, content);
         }
     }
     /// The button came up: the scrollbar lets go.
-    pub(super) fn release(&mut self) {
+    pub fn release(&mut self) {
         self.scroll.release();
     }
     fn focused(&mut self) -> Option<(Option<&'static str>, &mut EditBox)> {
@@ -272,7 +285,7 @@ impl RulesScreen {
         }
     }
     /// Run an edit on the focused box, then its responder.
-    pub(super) fn edit(&mut self, f: impl FnOnce(&mut EditBox)) {
+    pub fn edit(&mut self, f: impl FnOnce(&mut EditBox)) {
         let Some((rule, b)) = self.focused() else {
             return;
         };
@@ -282,12 +295,12 @@ impl RulesScreen {
             self.edited(rule);
         }
     }
-    pub(super) fn typing(&self) -> bool {
+    pub fn typing(&self) -> bool {
         !self.confirm && (self.search.focused || self.numbers.iter().any(|(_, b)| b.focused))
     }
 
     /// A left click; Some when the screen closes.
-    pub(super) fn click(
+    pub fn click(
         &mut self,
         atlas: &HudAtlas,
         cursor: (f32, f32),
@@ -355,12 +368,7 @@ impl RulesScreen {
         }
     }
     /// Whether a click lands on a button (for its sound).
-    pub(super) fn clicks_button(
-        &self,
-        atlas: &HudAtlas,
-        cursor: (f32, f32),
-        size: (f32, f32),
-    ) -> bool {
+    pub fn clicks_button(&self, atlas: &HudAtlas, cursor: (f32, f32), size: (f32, f32)) -> bool {
         let (w, h) = size;
         let on = |(x, y): (f32, f32)| ui::hovered(cursor, x, y, 150.0, 20.0);
         if self.confirm {
@@ -377,9 +385,9 @@ impl RulesScreen {
         })
     }
 
-    pub(super) fn draw(&mut self, batch: &mut HudBatch, atlas: &HudAtlas, cursor: (f32, f32)) {
+    pub fn draw(&mut self, batch: &mut HudBatch, atlas: &HudAtlas, cursor: (f32, f32)) {
         let (w, h) = (batch.width, batch.height);
-        ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true);
+        ui::menu_background(batch, atlas, 0.0, 0.0, w, h, self.in_world);
         if self.confirm {
             let labels = [
                 Text::translate("gui.yes", &[]),
@@ -393,7 +401,7 @@ impl RulesScreen {
         self.scroll.clamp(HEADER, h - FOOTER, content);
         // RuleList: the in-world list background, its entries clipped to it,
         // then the separators and scrollbar.
-        ui::list_background(batch, atlas, HEADER, h - FOOTER, true);
+        ui::list_background(batch, atlas, HEADER, h - FOOTER, self.in_world);
         let first = batch.vertices.len();
         let hovered = self.hovered(rows.len(), cursor, (w, h));
         let (left, x) = (row_left(w), control_x(w));
@@ -450,7 +458,7 @@ impl RulesScreen {
             }
         }
         batch.clip_since(first, 0.0, HEADER, w, h - FOOTER);
-        ui::separators(batch, atlas, HEADER, h - FOOTER, true);
+        ui::separators(batch, atlas, HEADER, h - FOOTER, self.in_world);
         ui::scrollbar(
             batch,
             atlas,
@@ -526,8 +534,8 @@ mod tests {
 
     #[test]
     fn box_colours_are_vanillas() {
-        assert_eq!(VALID, horizon_client::hud::rgba(224, 224, 224, 255));
-        assert_eq!(INVALID, horizon_client::hud::rgba(255, 0, 0, 255));
+        assert_eq!(VALID, crate::hud::rgba(224, 224, 224, 255));
+        assert_eq!(INVALID, crate::hud::rgba(255, 0, 0, 255));
     }
 
     #[test]
diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index 70d882a98..801dedde9 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -35,9 +35,13 @@ fn entity_shader() -> String {
 #[cfg(test)]
 mod crumbling_tests;
 mod entity_batch;
+mod entity_outline;
 mod weather;
 use entity_batch::EntityBatch;
-pub use entity_batch::{SHADOW_OVERLAY, TRANSLUCENT_PARTICLE_OVERLAY, WATER_MASK_OVERLAY};
+pub use entity_batch::{
+    ENERGY_SWIRL_OVERLAY, SHADOW_OVERLAY, TRANSLUCENT_GLINT_ITEM_OVERLAY, TRANSLUCENT_ITEM_OVERLAY,
+    TRANSLUCENT_PARTICLE_OVERLAY, WATER_MASK_OVERLAY,
+};
 
 /// Window.getAppropriateLineWidth, in framebuffer pixels.
 pub fn outline_width(width: u32) -> f32 {
@@ -172,12 +176,13 @@ struct Globals {
     inverse_view: [[f32; 4]; 4],
     sunrise: [f32; 4],
     sun: [f32; 4],
-    /// x: sky fog end, y: cloud fog end, z: dark disc (camera below the horizon), w: unused.
+    /// x: sky fog end, y: cloud fog end, z: dark disc (camera below the horizon),
+    /// w: the glint strength (`GlintAlpha`).
     fog_ends: [f32; 4],
     /// Atlas rects (u0, v0, width, height) of end_sky.png and end_portal.png.
     end_portal_sprites: [[f32; 4]; 2],
     /// x: vanilla's `GameTime` uniform; y: nether cardinal lighting; z: how many
-    /// `dynamic_lights` are set; w unused.
+    /// `dynamic_lights` are set; w: the glint scroll clock (`Glint::scroll_ticks`).
     time: [f32; 4],
     /// Atlas rect of a destroy stage (entity.wgsl takes only its size: every stage's is the same,
     /// and each crack carries its own stage's origin).
@@ -247,6 +252,8 @@ pub struct Frame<'a> {
     pub outline: Vec<[f64; 6]>,
     /// `BlockOutlineRenderState.isTranslucent`: draw after translucent terrain.
     pub outline_after_terrain: bool,
+    /// `BlockOutlineRenderState.highContrast`: a thick black outline under a bright one.
+    pub outline_high_contrast: bool,
     /// `lines` with a colour and pixel width (`gizmos::camera_relative`):
     /// the fishing line and debug gizmos, depth tested, then gizmos drawn
     /// over everything.
@@ -256,10 +263,19 @@ pub struct Frame<'a> {
     /// drawn after the hand at its projection, without the bob or fog.
     pub debug_crosshair: &'a [[f32; 8]],
     pub hud: &'a HudBatch,
+    /// `GlintAlpha` (accessibility Glint Strength); the entity shader uses it
+    /// for held/world items, independent of what the HUD batch last drew.
+    pub glint_alpha: f32,
+    /// The glint scroll clock (`Glint::scroll_ticks`): entity.wgsl's
+    /// `ARMOR_ENTITY_GLINT_TEXTURING` phase.
+    pub glint_ticks: f32,
     /// CardinalLighting.Type.NETHER, otherwise DEFAULT.
     pub nether_lighting: bool,
     /// Camera-relative entity geometry textured from the shared atlas.
     pub entities: &'a [Vertex],
+    /// The glowing entities' silhouettes in their team colours (`OutlineBufferSource`),
+    /// outlined through walls after the hand.
+    pub glowing: &'a [Vertex],
     /// Runs of `entities` by entity, while a shader pack draws them (`pack_draw::EntitySpan`).
     pub entity_spans: &'a [pack_draw::EntitySpan],
     pub weather: &'a [crate::weather::Vertex],
@@ -377,6 +393,7 @@ pub struct Renderer {
     sky: wgpu::RenderPipeline,
     dark_disc: wgpu::RenderPipeline,
     lines: wgpu::RenderPipeline,
+    lines_secondary: wgpu::RenderPipeline,
     /// Gizmo lines (`RenderTypes.linesTranslucentNoDepthWrite`) and the
     /// always-on-top ones.
     debug_lines: wgpu::RenderPipeline,
@@ -391,6 +408,7 @@ pub struct Renderer {
     weather: weather::Weather,
     crumbling_pipeline: wgpu::RenderPipeline,
     shadow_blob_pipeline: wgpu::RenderPipeline,
+    translucent_item_pipeline: wgpu::RenderPipeline,
     /// `RenderPipelines.WATER_MASK`: depth writes only, no colour.
     water_mask_pipeline: wgpu::RenderPipeline,
     cloud_pipeline: wgpu::RenderPipeline,
@@ -400,6 +418,8 @@ pub struct Renderer {
     cloud_uniform: wgpu::Buffer,
     cloud_group: wgpu::BindGroup,
     additive_pipeline: wgpu::RenderPipeline,
+    /// `RenderPipelines.ENERGY_SWIRL`: additive, unlit, the sprite repeated within itself.
+    energy_swirl_pipeline: wgpu::RenderPipeline,
     lightning_pipeline: wgpu::RenderPipeline,
     lightning: lightning::Renderer,
     see_through_pipeline: wgpu::RenderPipeline,
@@ -407,6 +427,8 @@ pub struct Renderer {
     celestial_buffer: wgpu::Buffer,
     end_sky: end_sky::EndSky,
     stars: stars::Stars,
+    /// The glowing entities' outline (`LevelRenderer.entityOutlineTarget`).
+    entity_outline: entity_outline::EntityOutline,
     panorama: panorama::Panorama,
     /// `RenderPipelines.WORLD_BORDER` and its buffers.
     border_pipeline: wgpu::RenderPipeline,
@@ -511,10 +533,10 @@ pub struct Renderer {
     occlusion: occlusion::Occlusion,
     /// Resolution scale and FXAA (Horizon settings).
     world_post: world_post::Post,
-    /// HDR output (Horizon setting): `Some` while the swapchain is scRGB.
+    /// HDR output (Horizon setting): `Some` while the swapchain is HDR.
     hdr: Option<hdr::Hdr>,
-    /// Whether the window's surface can present scRGB.
-    hdr_capable: bool,
+    /// The HDR output the window's surface can present.
+    hdr_output: Option<hdr::Output>,
     /// The shader pack's post-processing, and the dimension (legacy id) it was loaded for.
     pack_post: Option<(i32, Option<pack_post::PackPost>)>,
     /// The post passes of one of Horizon's own shader packs; never beside `pack_post`'s.
@@ -1019,6 +1041,8 @@ impl Renderer {
         sprite_mips: &[crate::mipmap::Settings],
         animations: &[SpriteAnimation],
         hud_atlas: (&[u8], u32, u32),
+        glint: (&[u8], u32, u32),
+        glint_armor: (&[u8], u32, u32),
         forcefield: (&[u8], u32),
         panorama_faces: &panorama::Faces,
         prepared: Option<PreparedTextures>,
@@ -1071,7 +1095,7 @@ impl Renderer {
         let info = adapter.get_info();
         crate::graphics::suggest_reduced_far_detail(crate::graphics::lod_capped(&info));
         let size = window.inner_size();
-        let (config, present_modes, hdr_capable) = if let Some(surface) = &surface {
+        let (config, present_modes, hdr_output) = if let Some(surface) = &surface {
             let mut config = surface
                 .get_default_config(&adapter, size.width.max(1), size.height.max(1))
                 .ok_or("surface has no supported configuration")?;
@@ -1099,7 +1123,7 @@ impl Renderer {
                 ));
             }
             surface.configure(&device, &config);
-            (config, caps.present_modes.clone(), hdr::supported(&caps))
+            (config, caps.present_modes.clone(), hdr::output(&caps))
         } else {
             let format = wgpu::TextureFormat::Bgra8Unorm;
             let config = wgpu::SurfaceConfiguration {
@@ -1113,7 +1137,7 @@ impl Renderer {
                 view_formats: vec![format],
                 color_space: wgpu::SurfaceColorSpace::default(),
             };
-            (config, Vec::new(), false)
+            (config, Vec::new(), None)
         };
         let offscreen = surface
             .is_none()
@@ -1213,12 +1237,6 @@ impl Renderer {
                 attributes: &instance_attributes,
             }),
         ];
-        let line_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x3];
-        let line_buffers = [Some(wgpu::VertexBufferLayout {
-            array_stride: 24,
-            step_mode: wgpu::VertexStepMode::Instance,
-            attributes: &line_attributes,
-        })];
         let alpha_blend = wgpu::BlendState::ALPHA_BLENDING;
         let debug_line_attributes =
             wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x3,2=>Unorm8x4,3=>Float32];
@@ -1351,13 +1369,25 @@ impl Renderer {
             "Block outline",
             "vs_line",
             "fs_line",
-            &line_buffers,
+            &debug_line_buffers,
             wgpu::PrimitiveTopology::TriangleStrip,
             None,
             true,
             true,
             Some(alpha_blend),
         );
+        // RenderTypes.secondaryBlockOutline: the black stroke under a high contrast outline.
+        let lines_secondary = pipeline(
+            "Block outline secondary",
+            "vs_line",
+            "fs_line",
+            &debug_line_buffers,
+            wgpu::PrimitiveTopology::TriangleStrip,
+            None,
+            false,
+            true,
+            Some(alpha_blend),
+        );
         let debug_lines = pipeline(
             "Debug lines",
             "vs_debug_line",
@@ -1531,7 +1561,7 @@ impl Renderer {
         });
         let outline = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Outline"),
-            size: 24 * MAX_OUTLINE_EDGES,
+            size: 32 * 2 * MAX_OUTLINE_EDGES,
             usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
             mapped_at_creation: false,
         });
@@ -1572,7 +1602,68 @@ impl Renderer {
             atlas_pixels,
         );
         let atlas_view = atlas.create_view(&Default::default());
-        let mut hud = HudRenderer::new(&device, config.format.remove_srgb_suffix(), &atlas_view)?;
+        // vanilla's `GlintSampler`: enchanted_glint_item as its own texture,
+        // repeated per pixel (`clamp: false`), linear without mipmaps
+        // (`blur: true`).
+        let (glint_pixels, glint_width, glint_height) = glint;
+        let glint_texture = device.create_texture_with_data(
+            &queue,
+            &wgpu::TextureDescriptor {
+                label: Some("Enchanted glint"),
+                size: wgpu::Extent3d {
+                    width: glint_width,
+                    height: glint_height,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: wgpu::TextureFormat::Rgba8Unorm,
+                usage: wgpu::TextureUsages::TEXTURE_BINDING,
+                view_formats: &[],
+            },
+            wgpu::util::TextureDataOrder::LayerMajor,
+            glint_pixels,
+        );
+        let glint_view = glint_texture.create_view(&Default::default());
+        let glint_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            label: Some("Glint"),
+            address_mode_u: wgpu::AddressMode::Repeat,
+            address_mode_v: wgpu::AddressMode::Repeat,
+            mag_filter: wgpu::FilterMode::Linear,
+            min_filter: wgpu::FilterMode::Linear,
+            ..Default::default()
+        });
+        // ARMOR_ENTITY_GLINT_TEXTURING's sampler is vanilla's GlintSampler: the
+        // same repeat and linear filtering as the item glint.
+        let (glint_armor_pixels, glint_armor_width, glint_armor_height) = glint_armor;
+        let glint_armor_texture = device.create_texture_with_data(
+            &queue,
+            &wgpu::TextureDescriptor {
+                label: Some("Enchanted armor glint"),
+                size: wgpu::Extent3d {
+                    width: glint_armor_width,
+                    height: glint_armor_height,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: wgpu::TextureFormat::Rgba8Unorm,
+                usage: wgpu::TextureUsages::TEXTURE_BINDING,
+                view_formats: &[],
+            },
+            wgpu::util::TextureDataOrder::LayerMajor,
+            glint_armor_pixels,
+        );
+        let glint_armor_view = glint_armor_texture.create_view(&Default::default());
+        let mut hud = HudRenderer::new(
+            &device,
+            config.format.remove_srgb_suffix(),
+            &atlas_view,
+            &glint_view,
+            &glint_sampler,
+        )?;
         hud.atlas_texture = Some(atlas.clone());
         let entity_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some("Horizon entities"),
@@ -1618,6 +1709,29 @@ impl Renderer {
                     vf,
                     wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                 ),
+                entry(
+                    5,
+                    vf,
+                    wgpu::BindingType::Texture {
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        multisampled: false,
+                    },
+                ),
+                entry(
+                    6,
+                    vf,
+                    wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                ),
+                entry(
+                    7,
+                    vf,
+                    wgpu::BindingType::Texture {
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        multisampled: false,
+                    },
+                ),
             ],
         });
         let weather = weather::Weather::new(
@@ -1654,6 +1768,18 @@ impl Renderer {
                     binding: 4,
                     resource: wgpu::BindingResource::Sampler(&lightmap_sampler),
                 },
+                wgpu::BindGroupEntry {
+                    binding: 5,
+                    resource: wgpu::BindingResource::TextureView(&glint_view),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 6,
+                    resource: wgpu::BindingResource::Sampler(&glint_sampler),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 7,
+                    resource: wgpu::BindingResource::TextureView(&glint_armor_view),
+                },
             ],
         });
         let hand_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
@@ -1680,6 +1806,18 @@ impl Renderer {
                     binding: 4,
                     resource: wgpu::BindingResource::Sampler(&lightmap_sampler),
                 },
+                wgpu::BindGroupEntry {
+                    binding: 5,
+                    resource: wgpu::BindingResource::TextureView(&glint_view),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 6,
+                    resource: wgpu::BindingResource::Sampler(&glint_sampler),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 7,
+                    resource: wgpu::BindingResource::TextureView(&glint_armor_view),
+                },
             ],
         });
         let entity_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
@@ -1724,7 +1862,7 @@ impl Renderer {
             usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
             mapped_at_creation: false,
         });
-        let entity_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4];
+        let entity_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2];
         let entity_vertex = [Some(wgpu::VertexBufferLayout {
             array_stride: std::mem::size_of::<Vertex>() as u64,
             step_mode: wgpu::VertexStepMode::Vertex,
@@ -1818,25 +1956,40 @@ impl Renderer {
             false,
         );
         // RenderPipelines.ENTITY_SHADOW: translucent, depth test without
-        // writes. The quads lie on the block tops like vanilla's, but the
-        // terrain under them snaps to the subpixel grid at other vertices, so
-        // at a slant their depths differ by up to 1/256 of a pixel's depth
-        // slope and whole shadows failed the test. The bias covers that and
-        // the rounding, and stays below the 0.001 a model's feet sit higher
-        // (1/27 of a pixel's slope at the 16-block shadow range in 720p).
+        // writes. The quads lie exactly on the block tops like vanilla's, but
+        // terrain and shadows are separate draw paths, so their fp32 depth
+        // interpolations disagree by a few dozen ulps of the fragment depth
+        // and the shadow's rim z-fights with the block top (speckle that
+        // re-rolls as the camera drifts a subpixel). A constant bias of 128
+        // ulps covers that spread at any resolution while staying far below
+        // the 0.001 a model's feet sit higher, so shadows never bleed onto
+        // the feet.
         let shadow_blob_pipeline = entity_pipeline(
             "Entity shadows",
             None,
             false,
             wgpu::CompareFunction::GreaterEqual,
             wgpu::DepthBiasState {
-                constant: 16,
+                constant: 128,
                 slope_scale: 0.015,
                 clamp: 0.0,
             },
             alpha_blend,
             false,
         );
+        // RenderPipelines.ITEM_TRANSLUCENT: blended, depth tested. Drawn before
+        // translucent terrain, it cannot write depth: the water behind a
+        // glass item would fail the test and vanish (vanilla sorts these in
+        // its order independent transparency pass instead).
+        let translucent_item_pipeline = entity_pipeline(
+            "Translucent items",
+            None,
+            false,
+            wgpu::CompareFunction::GreaterEqual,
+            Default::default(),
+            alpha_blend,
+            false,
+        );
         let cloud_pipeline = entity_pipeline(
             "Clouds",
             Some(wgpu::Face::Back),
@@ -1865,7 +2018,29 @@ impl Renderer {
             alpha_blend,
             false,
         );
-        let lightning_attributes = wgpu::vertex_attr_array![6=>Float32x3];
+        // RenderPipelines.ENERGY_SWIRL: BlendFunction.ADDITIVE (one, one), no culling; no depth
+        // writes either: vanilla sorts the quads far to near, so every face passes the test.
+        let one_one = wgpu::BlendComponent {
+            src_factor: wgpu::BlendFactor::One,
+            dst_factor: wgpu::BlendFactor::One,
+            operation: wgpu::BlendOperation::Add,
+        };
+        let energy_swirl_pipeline = entity_pipeline_with(
+            "Energy swirls",
+            None,
+            false,
+            wgpu::CompareFunction::GreaterEqual,
+            Default::default(),
+            wgpu::BlendState {
+                color: one_one,
+                alpha: one_one,
+            },
+            false,
+            "fs_energy_swirl",
+            wgpu::ColorWrites::ALL,
+        );
+        // Attribute 7: 6 is the entity vertex buffer's glint UV.
+        let lightning_attributes = wgpu::vertex_attr_array![7=>Float32x3];
         let lightning_vertex = [
             entity_vertex[0].clone(),
             Some(wgpu::VertexBufferLayout {
@@ -1953,22 +2128,23 @@ impl Renderer {
             multisample: Default::default(),
             fragment: Some(wgpu::FragmentState {
                 module: &entity_shader,
-                entry_point: Some("fs_celestial"),
+                entry_point: Some("fs_sky_celestial"),
                 compilation_options: Default::default(),
                 targets: &[Some(wgpu::ColorTargetState {
                     format: config.format.remove_srgb_suffix(),
-                    // RenderPipelines.CELESTIAL: additive (src alpha, one). The
-                    // alpha goes to 0: HDR output (hdr.wgsl) lets the sun and
-                    // moon shine; nothing else reads the frame's alpha.
+                    // RenderPipelines.CELESTIAL: additive (src alpha, one), with
+                    // the colour premultiplied in fs_sky_celestial. Its alpha is
+                    // how much a texel adds: HDR output (hdr.wgsl) lets the sun's
+                    // and moon's discs shine; nothing else reads the frame's alpha.
                     blend: Some(wgpu::BlendState {
                         color: wgpu::BlendComponent {
-                            src_factor: wgpu::BlendFactor::SrcAlpha,
+                            src_factor: wgpu::BlendFactor::One,
                             dst_factor: wgpu::BlendFactor::One,
                             operation: wgpu::BlendOperation::Add,
                         },
                         alpha: wgpu::BlendComponent {
                             src_factor: wgpu::BlendFactor::Zero,
-                            dst_factor: wgpu::BlendFactor::Zero,
+                            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
                             operation: wgpu::BlendOperation::Add,
                         },
                     }),
@@ -2316,6 +2492,11 @@ impl Renderer {
         let uploads = upload::Uploads::new(&device);
         let section_uploads = upload::Uploads::with_chunk(&device, SECTION_UPLOAD_CHUNK);
         let stars = stars::Stars::new(&device, config.format.remove_srgb_suffix());
+        let entity_outline = entity_outline::EntityOutline::new(
+            &device,
+            (&entity_shader, &entity_layout, &entity_vertex),
+            config.format.remove_srgb_suffix(),
+        );
         let panorama = panorama::Panorama::new(
             &device,
             &queue,
@@ -2361,6 +2542,7 @@ impl Renderer {
             sky,
             dark_disc,
             lines,
+            lines_secondary,
             debug_lines,
             debug_lines_on_top,
             debug_line_buffer,
@@ -2371,6 +2553,7 @@ impl Renderer {
             weather,
             crumbling_pipeline,
             shadow_blob_pipeline,
+            translucent_item_pipeline,
             water_mask_pipeline,
             cloud_pipeline,
             cloud_mesh: Default::default(),
@@ -2379,6 +2562,7 @@ impl Renderer {
             cloud_uniform,
             cloud_group,
             additive_pipeline,
+            energy_swirl_pipeline,
             lightning_pipeline,
             lightning: lightning::Renderer::new(),
             see_through_pipeline,
@@ -2386,6 +2570,7 @@ impl Renderer {
             celestial_buffer,
             end_sky: end_sky::EndSky::default(),
             stars,
+            entity_outline,
             panorama,
             border_pipeline,
             border_group,
@@ -2456,7 +2641,7 @@ impl Renderer {
             occlusion: occlusion::Occlusion::new(crate::chunk::MIN_Y, crate::chunk::HEIGHT / 16),
             world_post,
             hdr: None,
-            hdr_capable,
+            hdr_output,
             pack_post: None,
             native: None,
             pass_timing: pack_timing::PassTiming::logging(),
@@ -2482,6 +2667,18 @@ impl Renderer {
             present_modes,
         })
     }
+    /// LevelRenderer.submitBlockOutline: the buffer holds `edges` per stroke, the black
+    /// secondary stroke first when high contrast is on.
+    fn draw_outline(&self, pass: &mut wgpu::RenderPass<'_>, edges: u32, high_contrast: bool) {
+        pass.set_vertex_buffer(0, self.outline.slice(..));
+        if high_contrast {
+            pass.set_pipeline(&self.lines_secondary);
+            pass.draw(0..4, 0..edges);
+        }
+        pass.set_pipeline(&self.lines);
+        let first = if high_contrast { edges } else { 0 };
+        pass.draw(0..4, first..first + edges);
+    }
     fn quad_indices(device: &wgpu::Device, quads: u32) -> wgpu::Buffer {
         let indices: Vec<u32> = (0..quads)
             .flat_map(|q| {
@@ -2990,24 +3187,24 @@ impl Renderer {
         }
     }
     /// The swapchain's configuration: `config` (what every pipeline draws in), or
-    /// scRGB while HDR output is on.
+    /// HDR10 or scRGB while HDR output is on.
     fn surface_config(&self) -> wgpu::SurfaceConfiguration {
         let mut config = self.config.clone();
-        if self.hdr.is_some() {
-            config.format = hdr::FORMAT;
-            config.view_formats = vec![hdr::FORMAT];
-            config.color_space = hdr::COLOR_SPACE;
+        if let Some(hdr) = &self.hdr {
+            config.format = hdr.output.format();
+            config.view_formats = vec![hdr.output.format()];
+            config.color_space = hdr.output.color_space();
             config.usage = wgpu::TextureUsages::RENDER_ATTACHMENT;
         }
         config
     }
-    /// HDR output (Horizon setting): scRGB at `paper_white` nits, the world's
+    /// HDR output (Horizon setting): HDR10 or scRGB at `paper_white` nits, the world's
     /// highlights expanded up to `peak` nits. Off where the surface can't present it.
     pub fn set_hdr(&mut self, on: bool, paper_white: f32, peak: f32) {
-        let on = on && self.hdr_capable && self.surface.is_some();
-        if on != self.hdr.is_some() {
-            self.hdr =
-                on.then(|| hdr::Hdr::new(&self.device, self.config.format.remove_srgb_suffix()));
+        let output = self.hdr_output.filter(|_| on && self.surface.is_some());
+        if output.is_some() != self.hdr.is_some() {
+            let format = self.config.format.remove_srgb_suffix();
+            self.hdr = output.map(|output| hdr::Hdr::new(&self.device, format, output));
             self.configure_surface();
         }
         if let Some(hdr) = &mut self.hdr
@@ -3194,7 +3391,7 @@ impl Renderer {
     /// The Mipmap Levels option: block textures sample at most `levels`
     /// reduced copies (0: none).
     pub fn set_mipmap_levels(&mut self, levels: u32) {
-        let levels = sprite_mipmap_limit(
+        let levels = crate::sprites::sprite_mipmap_limit(
             levels,
             self.sprite_textures[0].width(),
             self.sprite_minimum_size,
@@ -3475,7 +3672,7 @@ impl Renderer {
                 frame.fog.map_or(frame.distance.min(512.0), |f| f.sky_end),
                 frame.fog.map_or(2048.0, |f| f.cloud_end),
                 if frame.dark_disc { 1.0 } else { 0.0 },
-                0.0,
+                frame.glint_alpha,
             ],
             end_portal_sprites: frame.end_portal_sprites,
             crumbling_sprite: frame.crumbling_sprite,
@@ -3483,7 +3680,7 @@ impl Renderer {
                 frame.shader_game_time,
                 f32::from(frame.nether_lighting),
                 frame.dynamic_lights.len().min(crate::dynamic_light::MAX) as f32,
-                0.0,
+                frame.glint_ticks,
             ],
             outline_params: outline_params(self.config.width, self.config.height),
             dynamic_lights: {
@@ -3954,7 +4151,26 @@ impl Renderer {
         );
         let outline_edges = frame.outline.len().min(MAX_OUTLINE_EDGES as usize);
         if outline_edges > 0 {
-            let lines = outline_vertices(&frame.outline[..outline_edges], camera);
+            // The same per-line colour and pixel width layout as the gizmo lines. A high
+            // contrast outline is two strokes: the black one first, the bright one after it.
+            let edges = outline_vertices(&frame.outline[..outline_edges], camera);
+            let width = outline_width(self.config.width);
+            let stroke = |color: u32, width: f32| {
+                edges.iter().map(move |e| {
+                    let mut line = [0.0; 8];
+                    line[..6].copy_from_slice(e);
+                    line[6] = f32::from_bits(color);
+                    line[7] = width;
+                    line
+                })
+            };
+            let lines: Vec<[f32; 8]> = if frame.outline_high_contrast {
+                stroke(0xff00_0000, 7.0)
+                    .chain(stroke(0xff57_ffe1, width))
+                    .collect()
+            } else {
+                stroke(0x6600_0000, width).collect()
+            };
             self.uploads
                 .buffer(&mut encoder, &self.outline, 0, bytemuck::cast_slice(&lines));
         }
@@ -3979,8 +4195,10 @@ impl Renderer {
             crumbling_quads,
             translucent_crumbling_quads,
             water_mask_quads,
+            swirl_quads,
             shadow_quads,
             translucent_particle_quads,
+            translucent_item_quads,
         ] = self
             .entity_batch
             .update(entities, frame.additive, frame.hand, frame.see_through);
@@ -3989,8 +4207,10 @@ impl Renderer {
             + crumbling_quads
             + translucent_crumbling_quads
             + water_mask_quads
+            + swirl_quads
             + shadow_quads
-            + translucent_particle_quads;
+            + translucent_particle_quads
+            + translucent_item_quads;
         let cloud_quads = if let Some(input) = &frame.clouds {
             let (rebuilt, uniform) =
                 crate::spans::time("clouds", || self.cloud_mesh.prepare(input));
@@ -4051,6 +4271,13 @@ impl Renderer {
                 bytemuck::cast_slice(all_entities),
             );
         }
+        self.entity_outline.prepare(
+            &self.device,
+            &mut self.uploads,
+            &mut encoder,
+            frame.glowing,
+            [self.config.width, self.config.height],
+        );
         if let Some((rotation, brightness)) = frame.stars {
             self.stars.prepare(
                 &mut self.uploads,
@@ -4078,7 +4305,8 @@ impl Renderer {
             } else {
                 lightning::QUADS
             })
-            .max(weather_quads);
+            .max(weather_quads)
+            .max(frame.glowing.len() as u32 / 4);
         if max_quads > self.index_quads {
             self.index_quads = max_quads.next_power_of_two();
             self.indices = Self::quad_indices(&self.device, self.index_quads);
@@ -4513,6 +4741,17 @@ impl Renderer {
                 pass.draw_indexed(0..entity_quads * 6, 0, 0..1);
                 pass.set_bind_group(0, &self.group, &[]);
             }
+            if translucent_item_quads > 0 {
+                pass.set_pipeline(&self.translucent_item_pipeline);
+                pass.set_bind_group(0, &self.entity_group, &[]);
+                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
+                pass.draw_indexed(
+                    0..translucent_item_quads * 6,
+                    ((world_quads - translucent_item_quads) * 4) as i32,
+                    0..1,
+                );
+                pass.set_bind_group(0, &self.group, &[]);
+            }
             if !pack_draws_weather {
                 self.weather.draw(&mut pass, &self.entity_group);
             }
@@ -4530,7 +4769,11 @@ impl Renderer {
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
                 pass.draw_indexed(
                     0..shadow_quads * 6,
-                    ((world_quads - translucent_particle_quads - shadow_quads) * 4) as i32,
+                    ((world_quads
+                        - translucent_item_quads
+                        - translucent_particle_quads
+                        - shadow_quads)
+                        * 4) as i32,
                     0..1,
                 );
                 pass.set_bind_group(0, &self.group, &[]);
@@ -4554,6 +4797,21 @@ impl Renderer {
                 self.lightning.draw(&mut pass, &frame.lightning);
                 pass.set_bind_group(0, &self.group, &[]);
             }
+            if swirl_quads > 0 {
+                pass.set_pipeline(&self.energy_swirl_pipeline);
+                pass.set_bind_group(0, &self.entity_group, &[]);
+                pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
+                pass.draw_indexed(
+                    0..swirl_quads * 6,
+                    ((entity_quads
+                        + crumbling_quads
+                        + translucent_crumbling_quads
+                        + water_mask_quads)
+                        * 4) as i32,
+                    0..1,
+                );
+                pass.set_bind_group(0, &self.group, &[]);
+            }
             if additive_quads > 0 {
                 pass.set_pipeline(&self.additive_pipeline);
                 pass.set_bind_group(0, &self.entity_group, &[]);
@@ -4562,9 +4820,7 @@ impl Renderer {
                 pass.set_bind_group(0, &self.group, &[]);
             }
             if outline_edges > 0 && !frame.outline_after_terrain {
-                pass.set_pipeline(&self.lines);
-                pass.set_vertex_buffer(0, self.outline.slice(..));
-                pass.draw(0..4, 0..outline_edges as u32);
+                self.draw_outline(&mut pass, outline_edges as u32, frame.outline_high_contrast);
             }
             if debug_depth > 0 {
                 pass.set_pipeline(&self.debug_lines);
@@ -4611,7 +4867,8 @@ impl Renderer {
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
                 pass.draw_indexed(
                     0..translucent_particle_quads * 6,
-                    ((world_quads - translucent_particle_quads) * 4) as i32,
+                    ((world_quads - translucent_item_quads - translucent_particle_quads) * 4)
+                        as i32,
                     0..1,
                 );
                 pass.set_bind_group(0, &self.group, &[]);
@@ -4619,9 +4876,7 @@ impl Renderer {
             // LevelRenderer.executeClassicTransparency: translucent targets'
             // outlines follow terrain, so its blending cannot wash them out.
             if outline_edges > 0 && frame.outline_after_terrain {
-                pass.set_pipeline(&self.lines);
-                pass.set_vertex_buffer(0, self.outline.slice(..));
-                pass.draw(0..4, 0..outline_edges as u32);
+                self.draw_outline(&mut pass, outline_edges as u32, frame.outline_high_contrast);
             }
             pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
             // LevelRenderer: the world border after translucent terrain and weather.
@@ -4808,6 +5063,13 @@ impl Renderer {
                 0..1,
             );
         }
+        // GameRenderer.render: LevelRenderer.blitEntityOutline after the level and the hand.
+        self.entity_outline.draw(
+            &mut encoder,
+            &view_target,
+            &self.entity_group,
+            &self.indices,
+        );
         if !frame.screen.is_empty() {
             let attachments = [Some(wgpu::RenderPassColorAttachment {
                 view: &view_target,
@@ -5222,6 +5484,7 @@ mod tests {
                 color: 0xffff_ffff,
                 light: id,
                 normal: [0; 4],
+                glint_uv: [0.0, 0.0],
             }; 4]
         };
         let entities: Vec<_> = [
@@ -5240,7 +5503,7 @@ mod tests {
         let mut batch = super::EntityBatch::default();
         let counts = batch.update(&entities, &quad(3, 5), &quad(0, 6), &quad(0, 8));
         let vertices = &batch.combined;
-        assert_eq!(counts, [4, 1, 1, 0, 1, 1]);
+        assert_eq!(counts, [4, 1, 1, 0, 0, 1, 1, 0]);
         assert_eq!(
             vertices
                 .as_chunks::<4>()
@@ -5476,11 +5739,6 @@ mod tests {
     }
 }
 
-pub(crate) fn sprite_mipmap_limit(requested: u32, size: u32, minimum: u32, available: u32) -> u32 {
-    // Only the atlas native minimum determines how many resampling-only mips to skip.
-    let upscale = (size / minimum.max(1)).max(1).ilog2();
-    requested.saturating_add(upscale).min(available - 1)
-}
 #[cfg(test)]
 mod sprite_upload_tests {
     use super::*;
@@ -5541,13 +5799,6 @@ mod sprite_upload_tests {
         }
     }
     #[test]
-    fn mipmap_option_keeps_real_16px_reductions() {
-        for levels in 0..=4 {
-            assert_eq!(sprite_mipmap_limit(levels, 32, 16, 6), levels + 1);
-            assert_eq!(sprite_mipmap_limit(levels, 16, 16, 5), levels);
-        }
-    }
-    #[test]
     fn prepared_texture_uploads_preserve_layer_order_and_settings() {
         let size = 4;
         let layers = 5;
diff --git a/crates/horizon-client/src/gfx/end_sky.rs b/crates/horizon-client/src/gfx/end_sky.rs
index 15e9001fc..d74e053df 100644
--- a/crates/horizon-client/src/gfx/end_sky.rs
+++ b/crates/horizon-client/src/gfx/end_sky.rs
@@ -72,6 +72,8 @@ fn vertices(uv: [f32; 4]) -> Vec<Vertex> {
                         layer: 2,
                         color: 0xFF28_2828,
                         light: 0,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
diff --git a/crates/horizon-client/src/gfx/end_sky/tests.rs b/crates/horizon-client/src/gfx/end_sky/tests.rs
index 61266003d..5cd2bcf7f 100644
--- a/crates/horizon-client/src/gfx/end_sky/tests.rs
+++ b/crates/horizon-client/src/gfx/end_sky/tests.rs
@@ -12,15 +12,15 @@ fn geometry_matches_pre_residency_vertex_snapshots() {
     for (uv, expected) in [
         (
             [0.0, 0.0, 1.0, 1.0],
-            "f7ee23457fc557b33ecf09c9afaf858f3d8907e108abf06055f627523f733536",
+            "82a9be3f3ed1f733017df2c81dc6dff163f67bf739c768e3fd0f90f00c7802f6",
         ),
         (
             [0.125, 0.25, 0.375, 0.5],
-            "f74c4b8d23ec2b7c11b5752821d0733851bf11358f1b26f9448226ff62a6a318",
+            "05a058bd8e70cff900c8e1c81061892ed27866d86498ebe1e8ae5af4c3b770ef",
         ),
         (
             [0.13, 0.27, 0.41, 0.59],
-            "f0aaa39c5b22168bdc7c6c329acb4d3598a2feb61ff7b6f2850b644682749b39",
+            "93064b9fd2e745da46b927b2625edc8a381bb8c6e20b0f0880e816c4c1745ec1",
         ),
     ] {
         let mut mesh = vertices(uv);
@@ -31,10 +31,8 @@ fn geometry_matches_pre_residency_vertex_snapshots() {
                 if n == 0.0 { 0.0 } else { n }
             });
         }
-        assert_eq!(
-            format!("{:x}", Sha256::digest(bytemuck::cast_slice(&mesh))),
-            expected
-        );
+        let hash = format!("{:x}", Sha256::digest(bytemuck::cast_slice(&mesh)));
+        assert_eq!(hash, expected);
     }
 }
 
@@ -95,7 +93,7 @@ fn separate_draws_match_combined_celestial_pixels() {
         label: Some("End sky differential shader"),
         source: wgpu::ShaderSource::Wgsl(crate::gfx::entity_shader().into()),
     });
-    let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4];
+    let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2];
     let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
         label: Some("End sky differential pipeline"),
         layout: None,
@@ -305,6 +303,8 @@ fn separate_draws_match_combined_celestial_pixels() {
                             color: level * 0x01010101,
                             light: 0,
                             normal: [0; 4],
+
+                            glint_uv: [0.0, 0.0],
                         })
                         .to_vec()
                 };
diff --git a/crates/horizon-client/src/gfx/entity_batch.rs b/crates/horizon-client/src/gfx/entity_batch.rs
index 8153699fc..f71545f2c 100644
--- a/crates/horizon-client/src/gfx/entity_batch.rs
+++ b/crates/horizon-client/src/gfx/entity_batch.rs
@@ -3,16 +3,27 @@ use super::Vertex;
 
 /// Entity materials by a quad's overlay (`Vertex::layer`), in draw order:
 /// ordinary entities, breaking cracks (11), translucent breaking cracks (12),
-/// the boat water mask (13, `RenderPipelines.WATER_MASK`), entity shadows
-/// (14, `RenderPipelines.ENTITY_SHADOW`) and translucent-layer particles (15,
-/// drawn after translucent terrain: `SubmitNodeCollection.submitQuadParticleGroup`).
-const MATERIALS: usize = 6;
+/// the boat water mask (13, `RenderPipelines.WATER_MASK`), energy swirls
+/// (34, `RenderPipelines.ENERGY_SWIRL`), entity shadows (14,
+/// `RenderPipelines.ENTITY_SHADOW`), translucent-layer particles (15, drawn
+/// after translucent terrain: `SubmitNodeCollection.submitQuadParticleGroup`)
+/// and translucent item quads (32, drawn without depth writes).
+const MATERIALS: usize = 8;
 /// The overlay of depth-only quads that hide water (`RenderTypes.waterMask`).
 pub const WATER_MASK_OVERLAY: u32 = 13;
+/// The overlay of energy swirl quads (`RenderTypes.energySwirl`: the charged creeper's and the
+/// powered wither's armour). The light bytes carry the sprite's origin and the colour bytes its
+/// size (`breaking::stage_light`), the UV the scrolled position in the sprite.
+pub const ENERGY_SWIRL_OVERLAY: u32 = 34;
 /// The overlay of entity shadow quads (`RenderTypes.entityShadow`).
 pub const SHADOW_OVERLAY: u32 = 14;
 /// The overlay of translucent-layer particles (`SingleQuadParticle.Layer.translucent`).
 pub const TRANSLUCENT_PARTICLE_OVERLAY: u32 = 15;
+/// The overlay of item quads with translucent pixels (`Sheets.translucentItemSheet`,
+/// `RenderPipelines.ITEM_TRANSLUCENT`); past the creeper swell range (16 to 31).
+pub const TRANSLUCENT_ITEM_OVERLAY: u32 = 32;
+/// A translucent item with an enchantment glint.
+pub const TRANSLUCENT_GLINT_ITEM_OVERLAY: u32 = 33;
 
 #[derive(Default)]
 pub(super) struct EntityBatch {
@@ -43,8 +54,10 @@ impl EntityBatch {
                 11 => 1,
                 12 => 2,
                 WATER_MASK_OVERLAY => 3,
-                SHADOW_OVERLAY => 4,
-                TRANSLUCENT_PARTICLE_OVERLAY => 5,
+                ENERGY_SWIRL_OVERLAY => 4,
+                SHADOW_OVERLAY => 5,
+                TRANSLUCENT_PARTICLE_OVERLAY => 6,
+                TRANSLUCENT_ITEM_OVERLAY | TRANSLUCENT_GLINT_ITEM_OVERLAY => 7,
                 _ => 0,
             };
             self.buckets[material][counts[material]] = index;
@@ -96,12 +109,13 @@ mod tests {
     ) -> (Vec<Vertex>, [u32; MATERIALS]) {
         let mut combined = Vec::with_capacity(entities.len() + additive.len() + hand.len());
         let mut counts = [0; MATERIALS];
-        for (i, layer) in [0, 11, 12, 13, 14, 15].into_iter().enumerate() {
+        for (i, layer) in [0, 11, 12, 13, 34, 14, 15].into_iter().enumerate() {
             for quad in entities.as_chunks::<4>().0 {
                 let material = match quad[0].layer {
                     11 => 11,
                     12 => 12,
                     13 => 13,
+                    34 => 34,
                     14 => 14,
                     15 => 15,
                     _ => 0,
@@ -130,6 +144,8 @@ mod tests {
                 color: index as u32,
                 light: (index * 3) as u32,
                 normal: [1, 2, 3, 4],
+
+                glint_uv: [0.0, 0.0],
             })
             .collect()
     }
diff --git a/crates/horizon-client/src/gfx/entity_outline.rs b/crates/horizon-client/src/gfx/entity_outline.rs
new file mode 100644
index 000000000..748622019
--- /dev/null
+++ b/crates/horizon-client/src/gfx/entity_outline.rs
@@ -0,0 +1,311 @@
+//! The entity outline (`LevelRenderer.entityOutlineTarget`): the glowing entities'
+//! silhouettes in their team colours, drawn without depth so walls do not hide them
+//! (`RenderTypes.outline`), the `entity_outline` post chain over them (`entity_sobel`, then
+//! `entity_outline_box_blur` across and up), and `LevelRenderer.blitEntityOutline` onto
+//! the frame after the hand.
+use super::Vertex;
+
+/// `entityOutlineTarget`'s `GpuFormat.RGBA8_UNORM`.
+const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
+
+struct Targets {
+    size: [u32; 2],
+    /// `entityOutlineTarget`.
+    outline: wgpu::TextureView,
+    /// The chain's `swap` target.
+    swap: wgpu::TextureView,
+    /// What each pass reads: the outline (nearest), swap (bilinear), the outline
+    /// (bilinear), swap (nearest).
+    groups: [wgpu::BindGroup; 4],
+}
+
+pub(super) struct EntityOutline {
+    silhouette: wgpu::RenderPipeline,
+    /// Sobel, blur across, blur up (into `FORMAT`) and the blended blit (onto the frame).
+    passes: [wgpu::RenderPipeline; 4],
+    layout: wgpu::BindGroupLayout,
+    nearest: wgpu::Sampler,
+    bilinear: wgpu::Sampler,
+    vertices: wgpu::Buffer,
+    capacity: u64,
+    quads: u32,
+    targets: Option<Targets>,
+}
+
+impl EntityOutline {
+    /// `entity` draws the silhouettes with the entity shader's vertex stage and
+    /// `fs_outline`; `format` is the frame's.
+    pub(super) fn new(
+        device: &wgpu::Device,
+        entity: (
+            &wgpu::ShaderModule,
+            &wgpu::PipelineLayout,
+            &[Option<wgpu::VertexBufferLayout>],
+        ),
+        format: wgpu::TextureFormat,
+    ) -> Self {
+        let (entity_shader, entity_layout, entity_vertex) = entity;
+        // RenderPipelines.OUTLINE_NO_CULL: no depth test, the colour replaced.
+        let silhouette = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("Entity outline silhouettes"),
+            layout: Some(entity_layout),
+            vertex: wgpu::VertexState {
+                module: entity_shader,
+                entry_point: Some("vs_entity"),
+                compilation_options: Default::default(),
+                buffers: entity_vertex,
+            },
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            fragment: Some(wgpu::FragmentState {
+                module: entity_shader,
+                entry_point: Some("fs_outline"),
+                compilation_options: Default::default(),
+                targets: &[Some(FORMAT.into())],
+            }),
+            multiview_mask: None,
+            cache: None,
+        });
+        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Entity outline"),
+            source: wgpu::ShaderSource::Wgsl(include_str!("entity_outline.wgsl").into()),
+        });
+        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("Entity outline bindings"),
+            entries: &[
+                wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Texture {
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        multisampled: false,
+                    },
+                    count: None,
+                },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                    count: None,
+                },
+            ],
+        });
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("Entity outline"),
+            bind_group_layouts: &[Some(&layout)],
+            ..Default::default()
+        });
+        let pass = |entry: &str, target: wgpu::ColorTargetState| {
+            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                label: Some(entry),
+                layout: Some(&pipeline_layout),
+                vertex: wgpu::VertexState {
+                    module: &shader,
+                    entry_point: Some("vs_quad"),
+                    compilation_options: Default::default(),
+                    buffers: &[],
+                },
+                primitive: Default::default(),
+                depth_stencil: None,
+                multisample: Default::default(),
+                fragment: Some(wgpu::FragmentState {
+                    module: &shader,
+                    entry_point: Some(entry),
+                    compilation_options: Default::default(),
+                    targets: &[Some(target)],
+                }),
+                multiview_mask: None,
+                cache: None,
+            })
+        };
+        // BlendFunction.ENTITY_OUTLINE_BLIT over the colour only (write mask 7).
+        let blit = wgpu::ColorTargetState {
+            format,
+            blend: Some(wgpu::BlendState {
+                color: wgpu::BlendComponent {
+                    src_factor: wgpu::BlendFactor::SrcAlpha,
+                    dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+                    operation: wgpu::BlendOperation::Add,
+                },
+                alpha: wgpu::BlendComponent {
+                    src_factor: wgpu::BlendFactor::Zero,
+                    dst_factor: wgpu::BlendFactor::One,
+                    operation: wgpu::BlendOperation::Add,
+                },
+            }),
+            write_mask: wgpu::ColorWrites::COLOR,
+        };
+        let sampler = |label, filter| {
+            device.create_sampler(&wgpu::SamplerDescriptor {
+                label: Some(label),
+                mag_filter: filter,
+                min_filter: filter,
+                ..Default::default()
+            })
+        };
+        Self {
+            silhouette,
+            passes: [
+                pass("fs_sobel", FORMAT.into()),
+                pass("fs_blur_x", FORMAT.into()),
+                pass("fs_blur_y", FORMAT.into()),
+                pass("fs_blit", blit),
+            ],
+            layout,
+            nearest: sampler("Entity outline nearest", wgpu::FilterMode::Nearest),
+            bilinear: sampler("Entity outline bilinear", wgpu::FilterMode::Linear),
+            vertices: Self::vertex_buffer(device, 256),
+            capacity: 256,
+            quads: 0,
+            targets: None,
+        }
+    }
+
+    fn vertex_buffer(device: &wgpu::Device, capacity: u64) -> wgpu::Buffer {
+        device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Entity outline vertices"),
+            size: capacity * std::mem::size_of::<Vertex>() as u64,
+            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        })
+    }
+
+    /// Uploads this frame's silhouettes (`LevelRenderer.currentFrameRendersEntityOutline`
+    /// when there are any) and sizes the targets like the window.
+    pub(super) fn prepare(
+        &mut self,
+        device: &wgpu::Device,
+        uploads: &mut super::upload::Uploads,
+        encoder: &mut wgpu::CommandEncoder,
+        silhouettes: &[Vertex],
+        size: [u32; 2],
+    ) {
+        self.quads = (silhouettes.len() / 4) as u32;
+        if self.quads == 0 {
+            return;
+        }
+        let vertices = silhouettes.len() as u64;
+        if vertices > self.capacity {
+            self.capacity = vertices.next_power_of_two();
+            self.vertices = Self::vertex_buffer(device, self.capacity);
+        }
+        uploads.buffer(
+            encoder,
+            &self.vertices,
+            0,
+            bytemuck::cast_slice(silhouettes),
+        );
+        if self.targets.as_ref().is_some_and(|t| t.size == size) {
+            return;
+        }
+        let texture = |label| {
+            device
+                .create_texture(&wgpu::TextureDescriptor {
+                    label: Some(label),
+                    size: wgpu::Extent3d {
+                        width: size[0],
+                        height: size[1],
+                        depth_or_array_layers: 1,
+                    },
+                    mip_level_count: 1,
+                    sample_count: 1,
+                    dimension: wgpu::TextureDimension::D2,
+                    format: FORMAT,
+                    usage: wgpu::TextureUsages::RENDER_ATTACHMENT
+                        | wgpu::TextureUsages::TEXTURE_BINDING,
+                    view_formats: &[],
+                })
+                .create_view(&Default::default())
+        };
+        let outline = texture("Entity outline");
+        let swap = texture("Entity outline swap");
+        let group = |view: &wgpu::TextureView, sampler: &wgpu::Sampler| {
+            device.create_bind_group(&wgpu::BindGroupDescriptor {
+                label: Some("Entity outline pass"),
+                layout: &self.layout,
+                entries: &[
+                    wgpu::BindGroupEntry {
+                        binding: 0,
+                        resource: wgpu::BindingResource::TextureView(view),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 1,
+                        resource: wgpu::BindingResource::Sampler(sampler),
+                    },
+                ],
+            })
+        };
+        let groups = [
+            group(&outline, &self.nearest),
+            group(&swap, &self.bilinear),
+            group(&outline, &self.bilinear),
+            group(&swap, &self.nearest),
+        ];
+        self.targets = Some(Targets {
+            size,
+            outline,
+            swap,
+            groups,
+        });
+    }
+
+    /// `LevelRenderer.executeOutline`, the post chain and `blitEntityOutline` onto `frame`.
+    pub(super) fn draw(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        frame: &wgpu::TextureView,
+        entity_group: &wgpu::BindGroup,
+        indices: &wgpu::Buffer,
+    ) {
+        let Some(t) = self.targets.as_ref().filter(|_| self.quads > 0) else {
+            return;
+        };
+        let clear = wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT);
+        {
+            let mut pass = begin(encoder, "Entity outline", &t.outline, clear);
+            pass.set_pipeline(&self.silhouette);
+            pass.set_bind_group(0, entity_group, &[]);
+            pass.set_index_buffer(indices.slice(..), wgpu::IndexFormat::Uint32);
+            pass.set_vertex_buffer(0, self.vertices.slice(..));
+            pass.draw_indexed(0..self.quads * 6, 0, 0..1);
+        }
+        // post_effect/entity_outline.json; its last pass only copies swap back to the
+        // outline target, so the blit reads swap.
+        let steps = [
+            ("Entity outline sobel", &t.swap, clear),
+            ("Entity outline blur across", &t.outline, clear),
+            ("Entity outline blur up", &t.swap, clear),
+            ("Entity outline blit", frame, wgpu::LoadOp::Load),
+        ];
+        for (i, (label, view, load)) in steps.into_iter().enumerate() {
+            let mut pass = begin(encoder, label, view, load);
+            pass.set_pipeline(&self.passes[i]);
+            pass.set_bind_group(0, &t.groups[i], &[]);
+            pass.draw(0..3, 0..1);
+        }
+    }
+}
+
+fn begin<'e>(
+    encoder: &'e mut wgpu::CommandEncoder,
+    label: &str,
+    view: &wgpu::TextureView,
+    load: wgpu::LoadOp<wgpu::Color>,
+) -> wgpu::RenderPass<'e> {
+    let attachments = [Some(wgpu::RenderPassColorAttachment {
+        view,
+        resolve_target: None,
+        depth_slice: None,
+        ops: wgpu::Operations {
+            load,
+            store: wgpu::StoreOp::Store,
+        },
+    })];
+    encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+        label: Some(label),
+        color_attachments: &attachments,
+        ..Default::default()
+    })
+}
diff --git a/crates/horizon-client/src/gfx/entity_outline.wgsl b/crates/horizon-client/src/gfx/entity_outline.wgsl
new file mode 100644
index 000000000..bd723f11e
--- /dev/null
+++ b/crates/horizon-client/src/gfx/entity_outline.wgsl
@@ -0,0 +1,60 @@
+// The entity_outline post chain (post_effect/entity_outline.json) over the silhouettes of
+// the glowing entities, then RenderTarget.blitAndBlendToTexture onto the frame.
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var source_sampler: sampler;
+
+struct PostOut {
+    @builtin(position) clip: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+};
+
+// screenquad.vsh, with v running down the rows as wgpu's textures do.
+@vertex fn vs_quad(@builtin(vertex_index) i: u32) -> PostOut {
+    let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
+    var out: PostOut;
+    out.clip = vec4(p * 2.0 - 1.0, 0.0, 1.0);
+    out.uv = vec2(p.x, 1.0 - p.y);
+    return out;
+}
+
+fn tap(uv: vec2<f32>) -> vec4<f32> {
+    return textureSampleLevel(source, source_sampler, uv, 0.0);
+}
+
+// entity_sobel.fsh: alpha marks where coverage changes, the colour is the mean of the
+// covered texels around.
+@fragment fn fs_sobel(in: PostOut) -> @location(0) vec4<f32> {
+    let texel = 1.0 / vec2<f32>(textureDimensions(source));
+    let center = tap(in.uv);
+    let left = tap(in.uv - vec2(texel.x, 0.0));
+    let right = tap(in.uv + vec2(texel.x, 0.0));
+    let up = tap(in.uv - vec2(0.0, texel.y));
+    let down = tap(in.uv + vec2(0.0, texel.y));
+    let total = clamp(abs(center.a - left.a) + abs(center.a - right.a)
+        + abs(center.a - up.a) + abs(center.a - down.a), 0.0, 1.0);
+    let color = center.rgb * center.a + left.rgb * left.a + right.rgb * right.a
+        + up.rgb * up.a + down.rgb * down.a;
+    return vec4(color * 0.2, total);
+}
+
+// entity_outline_box_blur.fsh at Radius 2: bilinear taps at -1.5 and 0.5 texels and half
+// a tap at 2; the colour averaged, the alpha summed.
+fn blur(uv: vec2<f32>, step: vec2<f32>) -> vec4<f32> {
+    let blurred = tap(uv + step * -1.5) + tap(uv + step * 0.5) + tap(uv + step * 2.0) / 2.0;
+    return vec4(blurred.rgb / 2.5, blurred.a);
+}
+
+// BlurDir (1, 0).
+@fragment fn fs_blur_x(in: PostOut) -> @location(0) vec4<f32> {
+    return blur(in.uv, vec2(1.0 / f32(textureDimensions(source).x), 0.0));
+}
+
+// BlurDir (0, 1): up the screen in GL's bottom-up textures, towards row 0 here.
+@fragment fn fs_blur_y(in: PostOut) -> @location(0) vec4<f32> {
+    return blur(in.uv, vec2(0.0, -1.0 / f32(textureDimensions(source).y)));
+}
+
+// blit_screen.fsh, blended by RenderPipelines.ENTITY_OUTLINE_BLIT.
+@fragment fn fs_blit(in: PostOut) -> @location(0) vec4<f32> {
+    return tap(in.uv);
+}
diff --git a/crates/horizon-client/src/gfx/hdr.rs b/crates/horizon-client/src/gfx/hdr.rs
index 11deed546..8b9df7af0 100644
--- a/crates/horizon-client/src/gfx/hdr.rs
+++ b/crates/horizon-client/src/gfx/hdr.rs
@@ -1,17 +1,50 @@
 //! HDR output (Horizon setting, off by default): the frame renders exactly as
 //! without it, into an 8-bit target in vanilla's gamma space, and one pass
-//! (`hdr.wgsl`) writes it to an scRGB swapchain at the player's paper white,
-//! expanding the world's highlights towards their peak brightness. The world
-//! is copied aside before the hand and HUD so only it is expanded.
+//! (`hdr.wgsl`) writes it to an HDR10 or scRGB swapchain at the player's paper
+//! white, expanding the world's highlights towards their peak brightness. The
+//! world is copied aside before the hand and HUD so only it is expanded.
 
-/// The swapchain format and colour space HDR output presents in.
-pub const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
-pub const COLOR_SPACE: wgpu::SurfaceColorSpace = wgpu::SurfaceColorSpace::ExtendedSrgbLinear;
+/// The swapchain HDR output presents to.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Output {
+    /// HDR10: 10-bit BT.2020 with the PQ curve, the display's own signal.
+    Pq,
+    /// scRGB: linear 16-bit float, BT.709 primaries, 1.0 = 80 nits.
+    ScRgb,
+}
 
-/// Whether `caps` can present scRGB.
-pub fn supported(caps: &wgpu::SurfaceCapabilities) -> bool {
-    caps.color_spaces(FORMAT)
-        .contains(wgpu::SurfaceColorSpaces::EXTENDED_SRGB_LINEAR)
+impl Output {
+    pub fn format(self) -> wgpu::TextureFormat {
+        match self {
+            Self::Pq => wgpu::TextureFormat::Rgb10a2Unorm,
+            Self::ScRgb => wgpu::TextureFormat::Rgba16Float,
+        }
+    }
+    pub fn color_space(self) -> wgpu::SurfaceColorSpace {
+        match self {
+            Self::Pq => wgpu::SurfaceColorSpace::Bt2100Pq,
+            Self::ScRgb => wgpu::SurfaceColorSpace::ExtendedSrgbLinear,
+        }
+    }
+    fn space(self) -> wgpu::SurfaceColorSpaces {
+        match self {
+            Self::Pq => wgpu::SurfaceColorSpaces::BT2100_PQ,
+            Self::ScRgb => wgpu::SurfaceColorSpaces::EXTENDED_SRGB_LINEAR,
+        }
+    }
+}
+
+/// The HDR output `caps` can present: HDR10 where offered, else scRGB.
+/// `HORIZON_HDR_OUTPUT=pq` or `scrgb` allows only that one.
+pub fn output(caps: &wgpu::SurfaceCapabilities) -> Option<Output> {
+    pick(caps, std::env::var("HORIZON_HDR_OUTPUT").ok().as_deref())
+}
+fn pick(caps: &wgpu::SurfaceCapabilities, only: Option<&str>) -> Option<Output> {
+    [(Output::Pq, "pq"), (Output::ScRgb, "scrgb")]
+        .into_iter()
+        .filter(|(_, name)| only.is_none_or(|o| o == *name))
+        .map(|(output, _)| output)
+        .find(|o| caps.color_spaces(o.format()).contains(o.space()))
 }
 
 struct Targets {
@@ -25,6 +58,7 @@ pub struct Hdr {
     layout: wgpu::BindGroupLayout,
     pipeline: wgpu::RenderPipeline,
     params: wgpu::Buffer,
+    pub output: Output,
     /// The frame's format: what every other pipeline draws in.
     format: wgpu::TextureFormat,
     targets: Option<Targets>,
@@ -36,7 +70,7 @@ pub struct Hdr {
 }
 
 impl Hdr {
-    pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
+    pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat, output: Output) -> Self {
         let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some("Horizon HDR"),
             source: wgpu::ShaderSource::Wgsl(include_str!("../hdr.wgsl").into()),
@@ -90,7 +124,7 @@ impl Hdr {
                 entry_point: Some("fs_hdr"),
                 compilation_options: Default::default(),
                 targets: &[Some(wgpu::ColorTargetState {
-                    format: FORMAT,
+                    format: output.format(),
                     blend: None,
                     write_mask: wgpu::ColorWrites::ALL,
                 })],
@@ -100,7 +134,7 @@ impl Hdr {
         });
         let params = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Horizon HDR parameters"),
-            size: 16,
+            size: 32,
             usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
             mapped_at_creation: false,
         });
@@ -108,6 +142,7 @@ impl Hdr {
             layout,
             pipeline,
             params,
+            output,
             format,
             targets: None,
             debug: std::env::var_os("HORIZON_HDR_DEBUG").is_some_and(|v| v == "1"),
@@ -198,6 +233,10 @@ impl Hdr {
             (self.peak / paper).max(1.0),
             f32::from(u8::from(world)),
             f32::from(u8::from(self.debug)),
+            f32::from(u8::from(self.output == Output::Pq)),
+            0.0,
+            0.0,
+            0.0,
         ];
         queue.write_buffer(&self.params, 0, bytemuck::cast_slice(&params));
         let view = target.create_view(&Default::default());
@@ -220,3 +259,37 @@ impl Hdr {
         pass.draw(0..3, 0..1);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{Output, pick};
+    use wgpu::{SurfaceColorSpaces as S, TextureFormat as F};
+
+    fn caps(offered: &[(F, S)]) -> wgpu::SurfaceCapabilities {
+        wgpu::SurfaceCapabilities {
+            format_capabilities: offered
+                .iter()
+                .map(|&(format, color_spaces)| wgpu::SurfaceFormatCapabilities {
+                    format,
+                    color_spaces,
+                })
+                .collect(),
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn hdr10_first_then_scrgb() {
+        let both = caps(&[
+            (F::Bgra8UnormSrgb, S::SRGB),
+            (F::Rgb10a2Unorm, S::BT2100_PQ | S::BT2100_HLG),
+            (F::Rgba16Float, S::EXTENDED_SRGB_LINEAR),
+        ]);
+        assert_eq!(pick(&both, None), Some(Output::Pq));
+        assert_eq!(pick(&both, Some("scrgb")), Some(Output::ScRgb));
+        let scrgb = caps(&[(F::Rgba16Float, S::EXTENDED_SRGB_LINEAR)]);
+        assert_eq!(pick(&scrgb, None), Some(Output::ScRgb));
+        assert_eq!(pick(&scrgb, Some("pq")), None);
+        assert_eq!(pick(&caps(&[(F::Bgra8UnormSrgb, S::SRGB)]), None), None);
+    }
+}
diff --git a/crates/horizon-client/src/gfx/lightning.rs b/crates/horizon-client/src/gfx/lightning.rs
index 251dbf00e..d979bb368 100644
--- a/crates/horizon-client/src/gfx/lightning.rs
+++ b/crates/horizon-client/src/gfx/lightning.rs
@@ -77,6 +77,8 @@ fn geometry(seed: i64, uv: [f32; 2]) -> Vec<Vertex> {
                             layer: 2,
                             color,
                             light: 240 | 240 << 8,
+
+                            glint_uv: [0.0, 0.0],
                         });
                     }
                 }
diff --git a/crates/horizon-client/src/gfx/lightning/tests/mod.rs b/crates/horizon-client/src/gfx/lightning/tests/mod.rs
index f89f402de..66959ce54 100644
--- a/crates/horizon-client/src/gfx/lightning/tests/mod.rs
+++ b/crates/horizon-client/src/gfx/lightning/tests/mod.rs
@@ -60,6 +60,8 @@ fn reference(seed: i64, at: [f64; 3], camera: DVec3, uv: [f32; 2]) -> Vec<Vertex
                                 layer: 2,
                                 color,
                                 light: 240 | 240 << 8,
+
+                                glint_uv: [0.0, 0.0],
                             });
                         }
                     }
@@ -225,8 +227,9 @@ fn retained_gpu_draw_matches_transient_additive_draw() {
         label: Some("Lightning differential shader"),
         source: wgpu::ShaderSource::Wgsl(crate::gfx::entity_shader().into()),
     });
-    let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4];
-    let offsets = wgpu::vertex_attr_array![6=>Float32x3];
+    let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2];
+    // Attribute 7: 6 is the entity vertex buffer's glint UV.
+    let offsets = wgpu::vertex_attr_array![7=>Float32x3];
     let vertices = [Some(wgpu::VertexBufferLayout {
         array_stride: std::mem::size_of::<Vertex>() as u64,
         step_mode: wgpu::VertexStepMode::Vertex,
diff --git a/crates/horizon-client/src/gfx/pack_entities.rs b/crates/horizon-client/src/gfx/pack_entities.rs
index ab3c66c69..c6bcd8beb 100644
--- a/crates/horizon-client/src/gfx/pack_entities.rs
+++ b/crates/horizon-client/src/gfx/pack_entities.rs
@@ -405,12 +405,12 @@ pub(super) fn quad_indices(device: &wgpu::Device, quads: u32) -> wgpu::Buffer {
 }
 
 /// Whether a run holds only geometry a gbuffers program can draw from the shared atlas: no
-/// celestial body, cloud, beam, End portal or crack (overlay codes Horizon's entity shader
-/// draws in its own way; entity.wgsl).
+/// celestial body, cloud, beam, End portal, crack or energy swirl (overlay codes Horizon's entity
+/// shader draws in its own way; entity.wgsl).
 fn plain(run: &[Vertex]) -> bool {
     run.iter()
         .step_by(4)
-        .all(|v| !matches!(v.layer, 2 | 4 | 6 | 9 | 10 | 11 | 12))
+        .all(|v| !matches!(v.layer, 2 | 4 | 6 | 9 | 10 | 11 | 12 | 34))
 }
 
 /// The programs of entity runs, in the order they draw.
diff --git a/crates/horizon-client/src/gfx/pack_weather.rs b/crates/horizon-client/src/gfx/pack_weather.rs
index 3479450af..f6bef0219 100644
--- a/crates/horizon-client/src/gfx/pack_weather.rs
+++ b/crates/horizon-client/src/gfx/pack_weather.rs
@@ -135,6 +135,8 @@ impl PackWeather {
                 color: v.color,
                 light: v.light,
                 normal: [0; 4],
+
+                glint_uv: [0.0, 0.0],
             }
         }));
         if self.scratch.len() > self.capacity {
diff --git a/crates/horizon-client/src/gizmos.rs b/crates/horizon-client/src/gizmos.rs
index d4125710e..70e2b87f3 100644
--- a/crates/horizon-client/src/gizmos.rs
+++ b/crates/horizon-client/src/gizmos.rs
@@ -204,6 +204,19 @@ impl Gizmos {
             position[1] + f64::from(size.1),
             position[2] + half,
         ];
+        self.entity_box(min, max, position, eye_height, living, view);
+    }
+    /// The same for an entity whose box is not centred on its position
+    /// (a painting or an item frame): `min` and `max` are the box.
+    pub fn entity_box(
+        &mut self,
+        min: [f64; 3],
+        max: [f64; 3],
+        position: [f64; 3],
+        eye_height: f32,
+        living: bool,
+        view: (f32, f32),
+    ) {
         self.cuboid(min, max, WHITE, STROKE_WIDTH);
         if living {
             let eye = min[1] + f64::from(eye_height);
diff --git a/crates/horizon-client/src/graphics.rs b/crates/horizon-client/src/graphics.rs
index 4f6f04bc0..fbf67f9ad 100644
--- a/crates/horizon-client/src/graphics.rs
+++ b/crates/horizon-client/src/graphics.rs
@@ -216,15 +216,19 @@ pub const INTEGRATED_LOD_DISTANCE: u32 = 128;
 pub fn lod_capped(info: &wgpu::AdapterInfo) -> bool {
     info.device_type == wgpu::DeviceType::IntegratedGpu && !info.name.starts_with("Apple")
 }
+/// A LOD distance as far terrain uses it on this adapter.
+pub fn lod_distance_capped(distance: u32, info: &wgpu::AdapterInfo) -> u32 {
+    let distance = distance.min(1024);
+    if lod_capped(info) {
+        distance.min(INTEGRATED_LOD_DISTANCE)
+    } else {
+        distance
+    }
+}
 impl Graphics {
     /// `lod_distance` as far terrain uses it on this adapter.
     pub fn lod_distance_on(&self, info: &wgpu::AdapterInfo) -> u32 {
-        let distance = self.lod_distance.min(1024);
-        if lod_capped(info) {
-            distance.min(INTEGRATED_LOD_DISTANCE)
-        } else {
-            distance
-        }
+        lod_distance_capped(self.lod_distance, info)
     }
 }
 #[derive(Clone, Debug, PartialEq)]
@@ -255,7 +259,7 @@ pub struct Graphics {
     pub resolution_scale: u32,
     /// FXAA over the world.
     pub fxaa: bool,
-    /// HDR output (scRGB), where the display path offers it.
+    /// HDR output (HDR10, or scRGB), where the display path offers it.
     pub hdr: bool,
     /// HDR paper white (where SDR white sits), in nits.
     pub hdr_paper_white: u32,
diff --git a/crates/horizon-client/src/graphics_style.rs b/crates/horizon-client/src/graphics_style.rs
index e02a0e1d9..62979903b 100644
--- a/crates/horizon-client/src/graphics_style.rs
+++ b/crates/horizon-client/src/graphics_style.rs
@@ -118,8 +118,9 @@ impl Style {
         (x, y, w): (f32, f32, f32),
         label: &Text,
         hover: bool,
+        active: bool,
     ) {
-        ui::button(batch, atlas, x, y, w, 20.0, label, true, hover);
+        ui::button(batch, atlas, x, y, w, 20.0, label, active, hover);
     }
     pub fn slider(
         &self,
diff --git a/crates/horizon-client/src/graphics_ui.rs b/crates/horizon-client/src/graphics_ui.rs
index 3c7a40e02..cb097c114 100644
--- a/crates/horizon-client/src/graphics_ui.rs
+++ b/crates/horizon-client/src/graphics_ui.rs
@@ -5,8 +5,7 @@ use crate::{
     graphics::{FarDetail, GraphicsApi, Overlay, Pacing, PresentMode, Preset},
     graphics_style::{Cost, STYLE},
     hud::{HudAtlas, HudBatch},
-    options_ui::Opt,
-    settings::Settings,
+    settings::{Opt, Settings},
     text::Text,
     ui,
 };
@@ -468,6 +467,10 @@ fn max_workers() -> u32 {
 }
 
 impl Item {
+    /// False for a setting whose system is not in Horizon yet (`Opt::available`).
+    fn available(self) -> bool {
+        !matches!(self, Item::Vanilla(o) if !o.available())
+    }
     /// On/off settings and their value.
     pub fn switch(self, s: &Settings) -> Option<bool> {
         let g = &s.horizon;
@@ -510,6 +513,9 @@ impl Item {
         }
     }
     pub fn set_slider(self, s: &mut Settings, v: f32) {
+        if !self.available() {
+            return;
+        }
         match self {
             Item::Vanilla(o) => o.set_slider(s, v),
             Item::Horizon(h) => h.set_slider(s, v),
@@ -517,6 +523,9 @@ impl Item {
         self.touched(s);
     }
     pub fn cycle(self, s: &mut Settings, back: bool, framebuffer: [i32; 2]) {
+        if !self.available() {
+            return;
+        }
         match self {
             Item::Vanilla(o) => o.cycle(s, back, framebuffer),
             Item::Horizon(h) => h.cycle(s, back),
@@ -689,6 +698,7 @@ impl GraphicsUi {
             })
             .collect();
         let mut index = 0;
+        let mut tooltip = None;
         for wd in &widgets {
             let hover = ui::hovered(cursor, wd.x, wd.y, wd.w, 20.0)
                 && (!wd.list || (cursor.1 >= top && cursor.1 < bottom));
@@ -700,6 +710,13 @@ impl GraphicsUi {
                         continue;
                     }
                     let label = item.label(s);
+                    let live = item.available();
+                    if hover && !live {
+                        tooltip = Some(atlas.font.split(
+                            &Text::literal("This feature is not yet available in Horizon."),
+                            170.0,
+                        ));
+                    }
                     match item.slider(s) {
                         Some(value) => STYLE.slider(
                             batch,
@@ -709,7 +726,14 @@ impl GraphicsUi {
                             value,
                             hover || self.dragging == Some(item),
                         ),
-                        None => STYLE.button(batch, atlas, (wd.x, wd.y, wd.w), &label, hover),
+                        None => STYLE.button(
+                            batch,
+                            atlas,
+                            (wd.x, wd.y, wd.w),
+                            &label,
+                            hover && live,
+                            live,
+                        ),
                     }
                     STYLE.description(
                         batch,
@@ -732,6 +756,7 @@ impl GraphicsUi {
                         (wd.x, wd.y, wd.w),
                         &Text::literal(label),
                         hover,
+                        true,
                     );
                 }
             }
@@ -751,6 +776,9 @@ impl GraphicsUi {
             Level::Advanced => "Graphics: Advanced",
         };
         STYLE.title(batch, atlas, &Text::literal(title));
+        if let Some(lines) = tooltip {
+            ui::tooltip(batch, atlas, &lines, cursor);
+        }
     }
     /// A press (or a drag with `drag`) at `(x, y)`.
     pub fn click(
@@ -788,6 +816,8 @@ impl GraphicsUi {
             }
             return match wd.target {
                 Target::Button(action) => vec![Action::ButtonClick, action],
+                // A disabled control does nothing: no sound, no preset change.
+                Target::Item(item) if !item.available() => Vec::new(),
                 Target::Item(item) => {
                     if item.slider(s).is_some() {
                         self.dragging = Some(item);
diff --git a/crates/horizon-client/src/hdr.wgsl b/crates/horizon-client/src/hdr.wgsl
index bf6c27cca..ec2ae118a 100644
--- a/crates/horizon-client/src/hdr.wgsl
+++ b/crates/horizon-client/src/hdr.wgsl
@@ -1,6 +1,6 @@
 // Horizon's HDR output pass: the frame, drawn as without HDR in vanilla's gamma
-// space, decoded to linear light at the paper white and written to the scRGB
-// swapchain (1.0 = 80 nits). Bright pixels of light sources that still show the
+// space, decoded to linear light at the paper white and written to the swapchain:
+// HDR10 (BT.2020, PQ) or scRGB (1.0 = 80 nits). Bright pixels of light sources that still show the
 // world as it was before the hand and HUD are expanded towards the peak.
 @group(0) @binding(0) var frame: texture_2d<f32>;
 @group(0) @binding(1) var world: texture_2d<f32>;
@@ -14,6 +14,8 @@ struct Params {
     world: f32,
     // 1 paints expanded pixels magenta (HORIZON_HDR_DEBUG=1).
     debug: f32,
+    // 1 for an HDR10 swapchain, 0 for scRGB.
+    pq: f32,
 };
 @group(0) @binding(2) var<uniform> params: Params;
 
@@ -30,14 +32,28 @@ const STRENGTH: f32 = 0.7;
 
 // Whether `c` still shows the world pixel `w`: the same, or darkened evenly
 // across its channels, as the vignette and other screen-wide tints darken it.
-// The hand, HUD and text replace pixels instead, so they never pass.
+// The hand, HUD and text replace pixels instead, so they never pass. The
+// channels are held to one factor, the ratio of their sums, so a channel at 0
+// stays 0; a step of 8-bit rounding is allowed on each.
 fn shows_world(c: vec3<f32>, w: vec3<f32>) -> bool {
     if all(c == w) {
         return true;
     }
-    let k = c / max(w, vec3(1.0 / 255.0));
-    let mean = (k.r + k.g + k.b) / 3.0;
-    return mean <= 1.01 && mean > 0.5 && all(abs(k - vec3(mean)) < vec3(0.03));
+    let f = (c.r + c.g + c.b) / max(w.r + w.g + w.b, 1.0 / 255.0);
+    return f <= 1.01 && f > 0.5 && all(abs(c - f * w) <= 0.03 * w + 1.0 / 255.0);
+}
+
+// Linear BT.709 to BT.2020 (ITU-R BT.2087), columns first.
+const BT709_TO_BT2020 = mat3x3<f32>(
+    vec3(0.6274, 0.0691, 0.0164),
+    vec3(0.3293, 0.9195, 0.0880),
+    vec3(0.0433, 0.0114, 0.8956),
+);
+
+// SMPTE ST 2084: nits (up to 10000) to the PQ signal.
+fn pq(nits: vec3<f32>) -> vec3<f32> {
+    let y = pow(clamp(nits / 10000.0, vec3(0.0), vec3(1.0)), vec3(0.1593017578125));
+    return pow((0.8359375 + 18.8515625 * y) / (1.0 + 18.6875 * y), vec3(78.84375));
 }
 
 @vertex fn vs_hdr(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
@@ -54,7 +70,10 @@ fn shows_world(c: vec3<f32>, w: vec3<f32>) -> bool {
     // The world's alpha is 0 on light-emitting blocks, the sun and the moon
     // (terrain.wgsl, the celestial pipeline): only those shine.
     if params.world > 0.5 && params.peak > 1.0 && w.a < 0.75 && shows_world(c, w.rgb) {
-        let y = 0.5 * (dot(light, vec3(0.2126, 0.7152, 0.0722)) + max(light.r, max(light.g, light.b)));
+        // Brightness of the world pixel, before the vignette darkens the frame
+        // toward its edges: a light source shines the same anywhere on screen.
+        let wl = pow(max(w.rgb, vec3(0.0)), vec3(2.2));
+        let y = 0.5 * (dot(wl, vec3(0.2126, 0.7152, 0.0722)) + max(wl.r, max(wl.g, wl.b)));
         let lift = smoothstep(LIFT_START, LIFT_FULL, y);
         if lift > 0.0 {
             let top = max(light.r, max(light.g, light.b));
@@ -65,5 +84,9 @@ fn shows_world(c: vec3<f32>, w: vec3<f32>) -> bool {
             }
         }
     }
-    return vec4(light * params.paper, 1.0);
+    let scrgb = light * params.paper;
+    if params.pq > 0.5 {
+        return vec4(pq(BT709_TO_BT2020 * scrgb * 80.0), 1.0);
+    }
+    return vec4(scrgb, 1.0);
 }
diff --git a/crates/horizon-client/src/health.rs b/crates/horizon-client/src/health.rs
index 25c719bfb..28391c496 100644
--- a/crates/horizon-client/src/health.rs
+++ b/crates/horizon-client/src/health.rs
@@ -25,19 +25,7 @@ use std::{fs, io, path::Path};
 pub(crate) type Attributes = LiveAttributes<Box<dyn FnMut() -> i32>>;
 pub(crate) type State = HurtState<DamageTypeId>;
 
-#[derive(Clone, Copy, Debug)]
-pub struct HealthRules {
-    pub difficulty: Difficulty,
-    pub natural_regeneration: bool,
-}
-impl Default for HealthRules {
-    fn default() -> Self {
-        Self {
-            difficulty: Difficulty::Normal,
-            natural_regeneration: true,
-        }
-    }
-}
+pub use crate::world::HealthRules;
 pub struct HealthResources {
     pub damage: Catalog,
     pub ids: PlayerFloatIds,
@@ -111,6 +99,12 @@ pub enum HealthEvent {
         amount: f32,
     },
     Phase(&'static str),
+    /// `Player.hurtArmor`: a hit that doesn't bypass armor wears the worn
+    /// pieces (`LivingEntity.getDamageAfterArmorAbsorb`); the game applies it.
+    ArmorHurt {
+        source: DamageTypeId,
+        amount: f32,
+    },
     /// `ServerLevel.broadcastDamageEvent`: the client's
     /// `LivingEntity.handleDamageEvent` plays the source's hurt sound.
     DamageBroadcast {
@@ -139,6 +133,7 @@ impl HealthEvent {
                 format!("record-damage {:08x}", amount.to_bits())
             }
             Self::Phase(name) => name.into(),
+            Self::ArmorHurt { amount, .. } => format!("hurt-armor {:08x}", amount.to_bits()),
             Self::DamageBroadcast { .. } => "broadcast-damage".into(),
             Self::Criterion { .. } => "hurt-criterion".into(),
         }
@@ -163,6 +158,12 @@ pub struct PlayerHealth {
     pub hurt: State,
     /// Client hurt animation; fully blocked hits only refresh the server's hurt state.
     pub hurt_animation_time: i32,
+    /// `Player.hurtDir` on a client: the yaw `ClientboundHurtAnimationPacket`
+    /// gave, which `GameRenderer.bobHurt` tilts the camera around.
+    pub hurt_dir: f32,
+    /// `ServerPlayer.hurtDir` of a hit the player's client hasn't been told
+    /// of yet (`indicateDamage`).
+    pub indicated_dir: Option<f32>,
     pub dead: bool,
     pub sync_velocity: bool,
     pub game_time: i64,
@@ -213,6 +214,8 @@ impl PlayerHealth {
                 last_stamp: 0,
             },
             hurt_animation_time: 0,
+            hurt_dir: 0.0,
+            indicated_dir: None,
             dead: false,
             sync_velocity: false,
             game_time: 0,
@@ -260,6 +263,18 @@ impl PlayerHealth {
         self.hurt.hurt_time = 10;
         self.hurt_animation_time = 10;
     }
+    /// `LivingEntity.animateHurt(yaw)` on a player: the tilt restarts around
+    /// `yaw` (`Player.animateHurt` keeps it as `hurtDir`).
+    pub fn animate_hurt_dir(&mut self, yaw: f32) {
+        self.animate_hurt();
+        self.hurt_dir = yaw;
+    }
+    /// `ServerPlayer.indicateDamage`: the hit's direction relative to where
+    /// the player looks, kept for the packet to its client.
+    pub fn indicate_damage(&mut self, xd: f64, zd: f64, yaw: f32) {
+        use horizon_core::geometry::trig::{RAD_TO_DEG, atan2};
+        self.indicated_dir = Some((atan2(zd, xd) * f64::from(RAD_TO_DEG) - f64::from(yaw)) as f32);
+    }
     /// `LocalPlayer.hurtTo` with `flashOnSetHealth`: a drop below the current
     /// health starts the hurt animation; `damageCooldownTime` (20 on a drop,
     /// 10 on a gain) is what lets `Hud.extractPlayerHealth` blink the hearts.
@@ -295,6 +310,20 @@ impl PlayerMotion {
         source: DamageTypeId,
         amount: f32,
         blocking: Option<Blocking>,
+    ) -> Result<BlockOutcome> {
+        self.hurt_caused_by(resources, rules, source, amount, blocking, false)
+    }
+    /// `hurt_blocking` from a source whose causing entity is a living
+    /// non-player (`living_cause`), which the `when_caused_by_living_non_player`
+    /// damage types scale with the difficulty.
+    pub fn hurt_caused_by(
+        &mut self,
+        resources: &HealthResources,
+        rules: HealthRules,
+        source: DamageTypeId,
+        amount: f32,
+        blocking: Option<Blocking>,
+        living_cause: bool,
     ) -> Result<BlockOutcome> {
         if self.client_side {
             return Ok(BlockOutcome::default());
@@ -315,6 +344,7 @@ impl PlayerMotion {
             invulnerable,
             rules,
             source,
+            living_cause,
             events: &mut self.events,
             dead: &mut h.dead,
             sync_velocity: &mut h.sync_velocity,
@@ -348,6 +378,13 @@ impl PlayerMotion {
         if outcome.hurt {
             h.hurt_animation_time = h.hurt.hurt_time;
         }
+        // `dealDefaultKnockback` ends in `indicateDamage` unless blocked: a
+        // hit with no direction of its own (`xd` and `zd` zero) is sent as
+        // the opposite of the player's yaw. A hit that has a direction
+        // replaces this (`mob_hits_player`).
+        if outcome.knockback && outcome.blocked <= 0.0 {
+            h.indicate_damage(0.0, 0.0, self.yaw);
+        }
         let after = h.health() + h.absorption();
         if self.hurt_log.len() >= HURT_LOG {
             self.hurt_log.remove(0);
@@ -390,6 +427,8 @@ pub(crate) struct Environment<'a> {
     pub(crate) invulnerable: bool,
     pub(crate) rules: HealthRules,
     pub(crate) source: DamageSource<'a, ()>,
+    /// The causing entity is a living non-player (a mob, or its projectile's owner).
+    pub(crate) living_cause: bool,
     pub(crate) events: &'a mut Vec<MotionEvent>,
     pub(crate) dead: &'a mut bool,
     pub(crate) sync_velocity: &'a mut bool,
@@ -517,9 +556,14 @@ impl ServerDamageEnvironment<Attributes> for Environment<'_> {
     fn bypasses(&mut self, kind: Bypass) -> io::Result<bool> {
         Ok(self.source.bypasses(kind))
     }
-    fn hurt_armor(&mut self, _: &mut Attributes, _: f32) -> io::Result<()> {
+    fn hurt_armor(&mut self, _: &mut Attributes, damage: f32) -> io::Result<()> {
+        // The worn armor lives in the game, which wears it from this event.
+        self.event(HealthEvent::ArmorHurt {
+            source: self.source.type_id(),
+            amount: damage,
+        });
         Ok(())
-    } // empty equipment
+    }
     fn has_resistance(&mut self) -> io::Result<bool> {
         Ok(self.status.resistance.is_some())
     }
@@ -604,8 +648,13 @@ impl ImmunityWorld for Environment<'_> {
     fn enchantment_immunity(&mut self) -> io::Result<bool> {
         Ok(false)
     }
-    fn damage_rule(&mut self, _: DamageRule) -> io::Result<bool> {
-        Ok(true)
+    fn damage_rule(&mut self, rule: DamageRule) -> io::Result<bool> {
+        Ok(match rule {
+            DamageRule::Drowning => self.rules.drowning_damage,
+            DamageRule::Fall => self.rules.fall_damage,
+            DamageRule::Fire => self.rules.fire_damage,
+            DamageRule::Freeze => self.rules.freeze_damage,
+        })
     }
     fn changing_dimension(&mut self) -> io::Result<bool> {
         Ok(false)
@@ -773,8 +822,13 @@ impl PlayerHurtWorld for Environment<'_> {
         Ok(())
     }
     fn scales_with_difficulty(&mut self, _: &mut State) -> io::Result<bool> {
-        Ok(self.source.definition().scaling == Scaling::Always)
-    } // no causing entity
+        // DamageSource.scalesWithDifficulty.
+        Ok(match self.source.definition().scaling {
+            Scaling::Never => false,
+            Scaling::Always => true,
+            Scaling::LivingNonPlayer => self.living_cause,
+        })
+    }
     fn difficulty(&mut self, _: &mut State) -> io::Result<Difficulty> {
         Ok(self.rules.difficulty)
     }
@@ -826,6 +880,31 @@ mod tests {
         assert!(!third.hurt && !third.knockback);
     }
 
+    /// #2141: an arrow that takes the last of the player's health must kill
+    /// them: `LivingEntity.hurt` leaves the health at zero and `Player.die`
+    /// follows.
+    #[test]
+    fn an_arrow_kills_a_player_at_one_health() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("movement-properties.nbt").exists() {
+            return;
+        }
+        let assets = crate::assets::Assets::load(&root).unwrap();
+        let resources = crate::motion::MotionResources::load(&root, &assets).unwrap();
+        let mut player =
+            crate::motion::PlayerMotion::new(&resources, horizon_core::geometry::Vec3::ZERO)
+                .unwrap();
+        player.set_health(1.0, false).unwrap();
+        let (health, rules) = (&resources.health, super::HealthRules::default());
+        let id = health.damage.id("minecraft:arrow").unwrap();
+        let hurt = player.hurt(health, rules, id, 5.0).unwrap();
+        assert!(hurt, "the arrow must hurt");
+        assert_eq!(player.health.health(), 0.0, "the health must be spent");
+        assert!(player.health.dead_or_dying(), "the player must be dead");
+    }
+
     #[test]
     fn hurt_sounds_follow_damage_effects() {
         // DamageEffects: HURT, THORNS, DROWNING, BURNING, POKING, FREEZING.
diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs
index 2b6acda41..2b9bae9b5 100644
--- a/crates/horizon-client/src/hud.rs
+++ b/crates/horizon-client/src/hud.rs
@@ -67,6 +67,11 @@ pub struct HudAtlas {
     pub fire_animations: Vec<(Rect, crate::sprites::SpriteAnimation)>,
     /// The default font (bitmap sheets in this atlas, unifont rasterized on demand).
     pub font: crate::font::Font,
+    /// `misc/enchanted_glint_item` as its own image: vanilla's `GlintSampler`
+    /// repeats it per pixel, which one sprite inside this atlas cannot.
+    pub glint: (Vec<u8>, u32, u32),
+    /// `misc/enchanted_glint_armor`, the armour layers' `GlintSampler`.
+    pub glint_armor: (Vec<u8>, u32, u32),
     white: Rect,
 }
 /// Atlas rows reserved for glyphs rasterized at run time.
@@ -526,6 +531,8 @@ impl HudAtlas {
             }
         }
         let white = sprites["horizon/white"];
+        let glint = Self::glint_texture(root, defaults, "enchanted_glint_item");
+        let glint_armor = Self::glint_texture(root, defaults, "enchanted_glint_armor");
         let font = crate::font::Font::load(
             root,
             &sprites,
@@ -542,10 +549,22 @@ impl HudAtlas {
             translucent,
             flags,
             fire_animations,
+            glint,
+            glint_armor,
             font,
             white,
         })
     }
+    /// `misc/<name>.png` on its own, or a transparent texel if the resource
+    /// pack lacks it.
+    fn glint_texture(root: &Path, defaults: &Path, name: &str) -> (Vec<u8>, u32, u32) {
+        let relative = format!("assets/minecraft/textures/misc/{name}.png");
+        let mut path = root.join(&relative);
+        if !path.exists() && defaults != root {
+            path = defaults.join(&relative);
+        }
+        decode(&path).map_or((vec![0; 4], 1, 1), |(w, h, pixels)| (pixels, w, h))
+    }
 }
 #[repr(C)]
 #[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
@@ -554,6 +573,9 @@ pub struct HudVertex {
     pub uv: [f32; 2],
     pub color: u32,
     pub depth: f32,
+    /// The `GLINT_TEXTURING` UV into the repeating glint texture, unused
+    /// unless `uv.x >= 2`.
+    pub glint_uv: [f32; 2],
 }
 /// The GUI Scale option (0 = auto).
 pub static GUI_SCALE: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
@@ -569,6 +591,8 @@ pub struct HudBatch {
     pub blends: Vec<(std::ops::Range<u32>, Blend)>,
     /// The textures and time of the `Blend::EndPortal` runs.
     pub end_portal: EndPortalFill,
+    /// `options.glintStrength` for the glint pass (`GlintAlpha`).
+    pub glint_alpha: f32,
     /// Screen's first vertex: the preceding HUD is part of its blurred background.
     pub blur_at: u32,
 }
@@ -620,6 +644,7 @@ impl HudBatch {
             patches: Vec::new(),
             blends: Vec::new(),
             end_portal: EndPortalFill::default(),
+            glint_alpha: 0.75,
             blur_at: 0,
         }
     }
@@ -695,6 +720,26 @@ impl HudBatch {
                 uv: uv[i],
                 color,
                 depth: 0.0,
+                glint_uv: [0.0, 0.0],
+            });
+        }
+    }
+    /// A quad whose texture is the `GLINT_TEXTURING` sample at `glint_uv`;
+    /// `uv` is the item's atlas UV, which the shader masks by.
+    pub fn quad_glint(
+        &mut self,
+        p: [[f32; 2]; 4],
+        uv: [[f32; 2]; 4],
+        glint_uv: [[f32; 2]; 4],
+        color: u32,
+    ) {
+        for i in [0, 1, 2, 0, 2, 3] {
+            self.vertices.push(HudVertex {
+                pos: p[i],
+                uv: uv[i],
+                color,
+                depth: 0.0,
+                glint_uv: glint_uv[i],
             });
         }
     }
@@ -705,6 +750,7 @@ impl HudBatch {
                 uv: uv[i],
                 color,
                 depth: p[i][2],
+                glint_uv: [0.0, 0.0],
             });
         }
     }
@@ -875,6 +921,7 @@ impl HudBatch {
                 uv,
                 color: c[i],
                 depth: 0.0,
+                glint_uv: [0.0, 0.0],
             });
         }
     }
@@ -912,6 +959,8 @@ impl HudBatch {
         // StringDecomposer.iterateFormatted inside Font.drawInternal:
         // `§` codes inside a span restyle what follows and are not drawn.
         let text = text.resolved();
+        // Language.getVisualOrder: shaped and reordered for right-to-left text.
+        let text = crate::bidi::visual(&text);
         let font = &atlas.font;
         let alpha = (color >> 24) as u8;
         let mut glyphs = Vec::new();
@@ -1053,6 +1102,8 @@ impl HudRenderer {
         device: &wgpu::Device,
         format: wgpu::TextureFormat,
         view: &wgpu::TextureView,
+        glint_view: &wgpu::TextureView,
+        glint_sampler: &wgpu::Sampler,
     ) -> Result<Self> {
         let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some("Horizon HUD"),
@@ -1097,6 +1148,22 @@ impl HudRenderer {
                     ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                     count: None,
                 },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 3,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Texture {
+                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        multisampled: false,
+                    },
+                    count: None,
+                },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 4,
+                    visibility: wgpu::ShaderStages::FRAGMENT,
+                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                    count: None,
+                },
             ],
         });
         let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
@@ -1115,6 +1182,14 @@ impl HudRenderer {
                     binding: 2,
                     resource: wgpu::BindingResource::Sampler(&sampler),
                 },
+                wgpu::BindGroupEntry {
+                    binding: 3,
+                    resource: wgpu::BindingResource::TextureView(glint_view),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 4,
+                    resource: wgpu::BindingResource::Sampler(glint_sampler),
+                },
             ],
         });
         let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
@@ -1122,7 +1197,8 @@ impl HudRenderer {
             bind_group_layouts: &[Some(&layout)],
             ..Default::default()
         });
-        let attributes = wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4,3=>Float32];
+        let attributes =
+            wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4,3=>Float32,4=>Float32x2];
         let create = |label, blend, fragment_entry, depth: bool| {
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                 label: Some(label),
@@ -1337,7 +1413,12 @@ impl HudRenderer {
             &self.uniform,
             0,
             bytemuck::bytes_of(&HudUniform::new(
-                [size[0] as f32, size[1] as f32, batch.scale, 0.0],
+                [
+                    size[0] as f32,
+                    size[1] as f32,
+                    batch.scale,
+                    batch.glint_alpha,
+                ],
                 batch.end_portal,
             )),
         );
@@ -1787,6 +1868,7 @@ mod tests {
                 patches: Vec::new(),
                 blends: Vec::new(),
                 end_portal: EndPortalFill::default(),
+                glint_alpha: 0.75,
                 blur_at: 0,
             };
             for (image_width, image_height) in [(195, 136), (176, 166), (176, 222)] {
diff --git a/crates/horizon-client/src/hud.wgsl b/crates/horizon-client/src/hud.wgsl
index ebb6dc2cb..435f7f062 100644
--- a/crates/horizon-client/src/hud.wgsl
+++ b/crates/horizon-client/src/hud.wgsl
@@ -7,28 +7,35 @@ struct Hud {
 @group(0) @binding(0) var<uniform> hud: Hud;
 @group(0) @binding(1) var atlas: texture_2d<f32>;
 @group(0) @binding(2) var atlas_sampler: sampler;
+// enchanted_glint_item on its own repeating texture (vanilla's GlintSampler).
+@group(0) @binding(3) var glint_tex: texture_2d<f32>;
+@group(0) @binding(4) var glint_sampler: sampler;
 struct Out {
     @builtin(position) clip: vec4<f32>,
     @location(0) uv: vec2<f32>,
     @location(1) color: vec4<f32>,
     // projection_from_position(gl_Position): the End portal's texProj0.
     @location(2) proj: vec4<f32>,
+    @location(3) glint_uv: vec2<f32>,
 }
-@vertex fn vs_main(@location(0) pos: vec2<f32>, @location(1) uv: vec2<f32>, @location(2) color: vec4<f32>, @location(3) depth: f32) -> Out {
+@vertex fn vs_main(@location(0) pos: vec2<f32>, @location(1) uv: vec2<f32>, @location(2) color: vec4<f32>, @location(3) depth: f32, @location(4) glint_uv: vec2<f32>) -> Out {
     let pixels = pos * hud.size.z;
     var out: Out;
     out.clip = vec4(pixels.x / hud.size.x * 2.0 - 1.0, 1.0 - pixels.y / hud.size.y * 2.0, depth, 1.0);
     out.uv = uv;
     out.color = color;
     out.proj = vec4(out.clip.xy * 0.5 + 0.5, out.clip.zw);
+    out.glint_uv = glint_uv;
     return out;
 }
 @fragment fn fs_main(in: Out) -> @location(0) vec4<f32> {
-    // u >= 2: flat vertex colour masked by the texture's alpha (enchantment glint).
+    // u >= 2: the GLINT_TEXTURING sample over the item, masked by the item's
+    // texture alpha (item.fsh's ALPHA_CUTOUT and GLINT path).
     if in.uv.x >= 2.0 {
-        let m = textureSample(atlas, atlas_sampler, in.uv - vec2(2.0, 0.0)).a * in.color.a;
-        if m < 0.004 { discard; }
-        return vec4(in.color.rgb, m);
+        let mask = textureSample(atlas, atlas_sampler, in.uv - vec2(2.0, 0.0)).a;
+        if mask < 0.1 { discard; }
+        let glint = hud.size.w * textureSample(glint_tex, glint_sampler, in.glint_uv);
+        return vec4(glint.rgb * glint.rgb, mask);
     }
     let c = textureSample(atlas, atlas_sampler, in.uv) * in.color;
     if c.a < 0.004 { discard; }
diff --git a/crates/horizon-client/src/hud_overlays.rs b/crates/horizon-client/src/hud_overlays.rs
index ebd860e08..8af2c2a0d 100644
--- a/crates/horizon-client/src/hud_overlays.rs
+++ b/crates/horizon-client/src/hud_overlays.rs
@@ -107,10 +107,11 @@ pub struct EffectIcon {
 
 impl From<&crate::effects::EffectInstance> for EffectIcon {
     fn from(effect: &crate::effects::EffectInstance) -> Self {
-        let def = crate::brewing::effect(effect.id);
+        let def = horizon_client_core::potions::effect(effect.id);
         Self {
             id: effect.id.to_owned(),
-            beneficial: def.is_some_and(|d| d.category == crate::brewing::Category::Beneficial),
+            beneficial: def
+                .is_some_and(|d| d.category == horizon_client_core::potions::Category::Beneficial),
             color: def.map_or(0, |d| d.color as i32),
             ambient: effect.ambient,
             duration: effect.duration,
@@ -191,6 +192,53 @@ pub fn effects(w: i32, demo: bool, effects: &[EffectIcon]) -> Vec<GuiDraw> {
     out
 }
 
+/// The saving indicator: `Hud.tickAutosaveIndicator` fades a value towards 1
+/// while the server is saving and `extractSavingIndicator` draws the text.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct SavingIndicator {
+    last: f32,
+    value: f32,
+}
+impl SavingIndicator {
+    /// `Hud.tickAutosaveIndicator`: `Mth.lerp(0.2F, value, saving ? 1 : 0)`.
+    pub fn tick(&mut self, saving: bool) {
+        self.last = self.value;
+        self.value += (if saving { 1.0 } else { 0.0 } - self.value) * 0.2;
+    }
+    /// `Hud.extractSavingIndicator` without the option check: the text in the
+    /// bottom right corner.
+    pub fn draw(
+        &self,
+        w: i32,
+        h: i32,
+        partial: f32,
+        font: &Font,
+        label: Text,
+        background: u32,
+    ) -> Vec<GuiDraw> {
+        let mut out = Vec::new();
+        if self.value <= 0.0 && self.last <= 0.0 {
+            return out;
+        }
+        let fade = (self.last + (self.value - self.last) * partial).clamp(0.0, 1.0);
+        let alpha = (255.0 * fade).floor() as u32;
+        if alpha > 0 {
+            let label_width = width(font, &label);
+            let color = crate::hud_layout::argb(alpha, 255, 255, 255);
+            text_with_backdrop(
+                &mut out,
+                label,
+                w - label_width - 5,
+                h - 9 - 5,
+                label_width,
+                color,
+                background,
+            );
+        }
+        out
+    }
+}
+
 /// Titles and the action bar: `Hud.title`, `subtitle`, `titleTime`, the
 /// fade times and `overlayMessageString` / `overlayMessageTime`.
 #[derive(Clone, Debug, PartialEq)]
diff --git a/crates/horizon-client/src/hunger.rs b/crates/horizon-client/src/hunger.rs
index 15eac144f..34f414d50 100644
--- a/crates/horizon-client/src/hunger.rs
+++ b/crates/horizon-client/src/hunger.rs
@@ -151,6 +151,7 @@ impl FoodWorld for TickWorld<'_> {
                 .damage
                 .source::<()>(id, None, None, None)
                 .expect("validated starvation source"),
+            living_cause: false,
             events: self.events,
             dead: self.dead,
             sync_velocity: self.sync_velocity,
diff --git a/crates/horizon-client/src/item_data.rs b/crates/horizon-client/src/item_data.rs
index ac624e85b..1bd80437f 100644
--- a/crates/horizon-client/src/item_data.rs
+++ b/crates/horizon-client/src/item_data.rs
@@ -52,6 +52,8 @@ pub struct StackData {
     pub pot_decorations: Option<Box<[Option<ItemStack>; 4]>>,
     /// `minecraft:bundle_contents`.
     pub bundle_contents: Vec<ItemStack>,
+    /// `BundleContents.selectedItem`: runtime only, never saved or sent.
+    pub bundle_selected: BundleSelected,
     /// `minecraft:suspicious_stew_effects`: (effect id, duration).
     pub stew_effects: Vec<(Arc<str>, i32)>,
     /// `minecraft:map_post_processing`: 0 lock, 1 scale.
@@ -60,6 +62,20 @@ pub struct StackData {
     /// max stack size...), kept as their saved values in key order.
     pub other: Vec<(String, Tag)>,
 }
+/// A bundle's selected item index (-1: none). Like vanilla's
+/// `BundleContents.equals` it is left out when stacks are compared.
+#[derive(Clone, Copy, Debug)]
+pub struct BundleSelected(pub i32);
+impl Default for BundleSelected {
+    fn default() -> Self {
+        Self(-1)
+    }
+}
+impl PartialEq for BundleSelected {
+    fn eq(&self, _: &Self) -> bool {
+        true
+    }
+}
 /// The components `components_tag` writes from modelled fields.
 const MODELLED: &[&str] = &[
     "minecraft:banner_patterns",
@@ -127,6 +143,9 @@ pub struct WrittenBook {
     pub author: String,
     pub generation: u8,
     pub pages: Vec<String>,
+    /// Each page's component when it is not a plain string, so that its
+    /// click events survive; empty or one per page.
+    pub page_tags: Vec<Tag>,
 }
 impl StackData {
     pub fn is_empty(&self) -> bool {
@@ -198,6 +217,19 @@ impl ItemStack {
     pub fn has_any_enchantments(&self) -> bool {
         !self.enchantments().is_empty() || !self.stored_enchantments().is_empty()
     }
+    /// `ItemStack.hasFoil`: an explicit `minecraft:enchantment_glint_override`
+    /// component wins, then the item's default override (`item_glint`), then a
+    /// non-empty `minecraft:enchantments` component (`Item.isFoil` is
+    /// `ItemStack.isEnchanted`; stored book enchantments do not count).
+    pub fn has_foil(&self, item_glint: bool) -> bool {
+        if let Some(Tag::Byte(flag)) = self
+            .data()
+            .and_then(|d| d.other("minecraft:enchantment_glint_override"))
+        {
+            return *flag != 0;
+        }
+        item_glint || !self.enchantments().is_empty()
+    }
     pub fn repair_cost(&self) -> u32 {
         self.data().map_or(0, |d| d.repair_cost)
     }
@@ -293,6 +325,21 @@ fn read_levels(t: Option<&Tag>) -> Levels {
 }
 /// A text component as stored by vanilla: a plain string or `{"text": ...}`.
 /// A `Filterable<String/Component>`: the value itself or `{raw: value}`.
+/// `ComponentSerialization.CODEC`'s short form: a plain text component with
+/// no style and no siblings is written as its string.
+fn plain_component(t: &Tag) -> Tag {
+    if let Tag::Compound(c) = t
+        && let Some(text @ Tag::String(_)) = c.get(&"text".into())
+        && c.iter().all(|(k, v)| {
+            k.to_string_lossy() == "text"
+                || (k.to_string_lossy() == "type"
+                    && matches!(v, Tag::String(s) if s.to_string_lossy() == "text"))
+        })
+    {
+        return text.clone();
+    }
+    t.clone()
+}
 fn filterable_text(t: &Tag) -> Option<String> {
     match t.get("raw") {
         Some(raw) => read_text(raw),
@@ -305,7 +352,9 @@ fn read_text(t: &Tag) -> Option<String> {
         // A component's root `text` may be empty with the visible words in
         // `extra` (every legacy display name ViaVersion produces looks like
         // this), so flatten the whole component instead of reading one key.
-        Tag::Compound(_) => Some(crate::entity_nbt::name_text(t).plain()),
+        // ComponentSerialization.CODEC also takes a list (its first element
+        // styling the rest), as servers behind ViaVersion send book pages.
+        Tag::Compound(_) | Tag::List(_) => Some(crate::entity_nbt::name_text(t).plain()),
         _ => None,
     }
 }
@@ -522,11 +571,14 @@ pub fn components_tag(damage: u32, data: Option<&StackData>) -> Option<Tag> {
             ));
         }
         if let Some(w) = &d.written {
-            let pages = w
-                .pages
-                .iter()
-                .map(|p| raw(Tag::String(p.as_str().into())))
-                .collect();
+            let pages = if w.page_tags.len() == w.pages.len() {
+                w.page_tags.iter().cloned().map(raw).collect()
+            } else {
+                w.pages
+                    .iter()
+                    .map(|p| raw(Tag::String(p.as_str().into())))
+                    .collect()
+            };
             entries.push((
                 "minecraft:written_book_content",
                 Tag::compound({
@@ -707,6 +759,13 @@ pub fn decode_components(components: Option<&Tag>) -> (u32, Option<Box<StackData
                     Some(Tag::List(pages)) => pages.iter().filter_map(filterable_text).collect(),
                     _ => Vec::new(),
                 },
+                page_tags: match b.get("pages") {
+                    Some(Tag::List(pages)) => pages
+                        .iter()
+                        .map(|p| plain_component(p.get("raw").unwrap_or(p)))
+                        .collect(),
+                    _ => Vec::new(),
+                },
             }),
         fireworks: c
             .get("minecraft:fireworks")
@@ -791,6 +850,7 @@ pub fn decode_components(components: Option<&Tag>) -> (u32, Option<Box<StackData
                 Arc::from(t.get("pattern").and_then(string)?.as_str()),
             ))
         }),
+        bundle_selected: BundleSelected::default(),
         other: Vec::new(),
     };
     let mut data = data;
@@ -899,6 +959,37 @@ mod tests {
         );
     }
 
+    #[test]
+    fn written_book_pages_may_be_component_lists() {
+        // A page as Hypixel sends it through ViaVersion: a list, not a compound.
+        let page = Tag::List(vec![
+            Tag::compound([("text", Tag::String("".into()))]),
+            Tag::compound([("text", Tag::String("Please read ".into()))]),
+            Tag::compound([("text", Tag::String("the rules".into()))]),
+        ]);
+        let book = Tag::compound([
+            (
+                "title",
+                Tag::compound([("raw", Tag::String("Rules".into()))]),
+            ),
+            ("author", Tag::String("Server".into())),
+            (
+                "pages",
+                Tag::List(vec![
+                    page,
+                    Tag::compound([("raw", Tag::String("Two".into()))]),
+                ]),
+            ),
+        ]);
+        let components = Tag::compound([("minecraft:written_book_content", book)]);
+        let (_, extra) = decode_components(Some(&components));
+        let pages = extra.and_then(|d| d.written.clone()).map(|w| w.pages);
+        assert_eq!(
+            pages,
+            Some(vec!["Please read the rules".to_owned(), "Two".to_owned()])
+        );
+    }
+
     #[test]
     fn banner_layers_and_shield_base_round_trip() {
         let mut stack = ItemStack::new("minecraft:shield", 1);
diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs
index 4f981b874..107da9208 100644
--- a/crates/horizon-client/src/item_render.rs
+++ b/crates/horizon-client/src/item_render.rs
@@ -41,11 +41,58 @@ use std::{
 pub struct ItemQuad {
     pub pos: [Vec3; 4],
     pub uv: [[f32; 2]; 4],
+    /// The model UVs `GLINT_TEXTURING` scrolls for the glint (vanilla's UV0,
+    /// or UV3 for a special model).
+    pub foil_uv: [[f32; 2]; 4],
     pub normal: Vec3,
     pub color: u32,
     pub foil: Foil,
     /// `MaterialInfo.lightEmission` (block light floor).
     pub light_emission: u8,
+    /// The quad's sprite has translucent pixels (`MaterialInfo.itemRenderType`
+    /// is a translucent sheet): drawn with the translucent entities.
+    pub translucent: bool,
+}
+/// `TextureTransform.setupGlintTexturing`'s inputs.
+#[derive(Clone, Copy, Debug)]
+pub struct Glint {
+    /// `options.glintSpeed` (vanilla default 0.5).
+    pub speed: f32,
+    /// `options.glintStrength` / shader `GlintAlpha` (vanilla default 0.75).
+    pub alpha: f32,
+    /// `Util.getMillis()`.
+    pub millis: f32,
+    /// The transform's scale: `GLINT_TEXTURING`'s 8.0 for GUI items,
+    /// `ENTITY_GLINT_TEXTURING`'s 0.5 for items in the world and
+    /// `ARMOR_ENTITY_GLINT_TEXTURING`'s 0.16 for armour (entity.wgsl).
+    pub scale: f32,
+}
+impl Glint {
+    /// `Util.getMillis() * glintSpeed * 8.0` as vanilla's long.
+    fn ticks(millis: f32, speed: f32) -> i64 {
+        (f64::from(millis) * f64::from(speed) * 8.0) as i64
+    }
+    /// The scroll clock modulo the common period of both offsets (110000 and
+    /// 30000 divide 330000), for `globals.time.w`: the entity shader derives
+    /// `ARMOR_ENTITY_GLINT_TEXTURING` from it.
+    pub fn scroll_ticks(millis: f32, speed: f32) -> f32 {
+        (Self::ticks(millis, speed) % 330_000) as f32
+    }
+    /// `TextureTransform.setupGlintTexturing(scale)` applied to the model UV:
+    /// translation(-o0, o1) * rotateZ(PI/18) * scale. The result repeats:
+    /// the shader samples the dedicated glint texture with vanilla's
+    /// repeating `GlintSampler`, so the UVs stay unwrapped.
+    pub fn uv(&self, model: [f32; 2]) -> [f32; 2] {
+        let ticks = Self::ticks(self.millis, self.speed);
+        let offset0 = (ticks % 110_000) as f32 / 110_000.0;
+        let offset1 = (ticks % 30_000) as f32 / 30_000.0;
+        let angle = std::f32::consts::PI / 18.0;
+        let (sin, cos) = angle.sin_cos();
+        [
+            model[0] * self.scale * cos - model[1] * self.scale * sin - offset0,
+            model[0] * self.scale * sin + model[1] * self.scale * cos + offset1,
+        ]
+    }
 }
 /// Which glint render type a quad uses.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -159,7 +206,7 @@ impl ItemRenderState {
             let m = pose * layer.matrix;
             match &layer.geometry {
                 LayerGeometry::Quads(baked) => {
-                    submit_quads(baked, layer, self.display, m, sprites, sink);
+                    submit_quads(renderer, baked, layer, self.display, m, sprites, sink);
                 }
                 LayerGeometry::Special { model, argument } => special::submit(
                     renderer,
@@ -203,6 +250,7 @@ pub fn argb(color: i32) -> u32 {
 
 /// `ItemFeatureRenderer.prepareMainSubmit` for one cuboid layer.
 fn submit_quads(
+    renderer: &ItemRenderer,
     baked: &BakedItemModel,
     layer: &LayerRender,
     display: DisplayContext,
@@ -216,6 +264,8 @@ fn submit_quads(
         FoilType::Special => Foil::Special,
     };
     let _ = display;
+    // Quads of one layer mostly share a sprite: look its translucency up once.
+    let mut last: Option<(&str, bool)> = None;
     for q in &baked.quads {
         let Some(r) = sprites
             .get(sprite_name(&q.material.sprite))
@@ -239,13 +289,25 @@ fn submit_quads(
         let pos = q.positions.map(|p| m.transform_point3(Vec3::from(p)));
         let uv =
             q.uv.map(|[u, v]| [r.u0 + (r.u1 - r.u0) * u, r.v0 + (r.v1 - r.v0) * v]);
+        let translucent = match last {
+            Some((sprite, translucent)) if sprite == q.material.sprite => translucent,
+            _ => {
+                let translucent = renderer
+                    .sprites
+                    .translucent(sprite_name(&q.material.sprite));
+                last = Some((&q.material.sprite, translucent));
+                translucent
+            }
+        };
         sink.quad(ItemQuad {
             pos,
             uv,
+            foil_uv: q.uv,
             normal: transform_normal(m, direction_vector(q.facing)),
             color: argb(color),
             foil,
             light_emission: q.light_emission,
+            translucent: translucent || q.material.force_translucent,
         });
     }
 }
@@ -260,6 +322,9 @@ struct FileSprites {
     root: PathBuf,
     permutations: Vec<PalettedPermutations>,
     cache: Mutex<HashMap<String, Option<SpriteMask>>>,
+    /// Sprites with a pixel that is neither fully transparent nor opaque
+    /// (`Transparency.hasTranslucent`), filled in as sprites load.
+    translucent: Mutex<HashMap<String, bool>>,
 }
 impl SpriteLookup for FileSprites {
     fn mask(&self, sprite: &str) -> Option<SpriteMask> {
@@ -283,6 +348,13 @@ fn argb_pixels(rgba: &[u8]) -> Vec<u32> {
         .collect()
 }
 impl FileSprites {
+    fn translucent(&self, sprite: &str) -> bool {
+        let known = |this: &Self| this.translucent.lock().ok()?.get(sprite).copied();
+        known(self).unwrap_or_else(|| {
+            self.mask(sprite);
+            known(self).unwrap_or(false)
+        })
+    }
     fn png(&self, sprite: &str, directory: &str) -> PathBuf {
         crate::atlas_sources::texture_path(&self.root, sprite, directory)
     }
@@ -303,6 +375,10 @@ impl FileSprites {
                 (w, h, pixels)
             }
         };
+        let translucent = argb.iter().any(|p| matches!(p >> 24, 1..=254));
+        if let Ok(mut cache) = self.translucent.lock() {
+            cache.insert(sprite.to_owned(), translucent);
+        }
         let alpha: Vec<u8> = argb.iter().map(|p| (p >> 24) as u8).collect();
         let animation = fs::read_to_string(png.with_extension("png.mcmeta"))
             .ok()
@@ -452,6 +528,7 @@ impl ItemRenderer {
                 root: root.to_path_buf(),
                 permutations,
                 cache: Mutex::default(),
+                translucent: Mutex::default(),
             },
             baked: Mutex::default(),
             extents: Mutex::default(),
@@ -653,6 +730,7 @@ pub fn tag_json(tag: &Tag) -> Value {
 /// The resolver's view of a client stack: its item, count and component patch.
 pub fn stack_view(stack: &crate::items::ItemStack) -> StackView {
     let mut view = StackView::new(&stack.item, stack.count as i32);
+    view.bundle_selected = stack.data().map_or(-1, |d| d.bundle_selected.0);
     if let Some(Tag::Compound(c)) = crate::item_data::components_tag(stack.damage, stack.data()) {
         for (k, v) in &c {
             let key = k.to_string_lossy();
@@ -679,6 +757,8 @@ pub struct WorldSink<'a> {
     pub light: u32,
     /// The level's diffuse lights; `None` leaves the colour unshaded.
     pub lights: Option<(Vec3, Vec3)>,
+    /// The `GLINT_TEXTURING` sample for foil quads (`None` leaves them unglinted).
+    pub glint: Option<Glint>,
 }
 impl ItemSink for WorldSink<'_> {
     fn quad(&mut self, q: ItemQuad) {
@@ -693,8 +773,19 @@ impl ItemSink for WorldSink<'_> {
         } else {
             self.light
         };
-        let overlay = if q.foil == Foil::None { 0 } else { 7 };
-        for (p, uv) in q.pos.iter().zip(q.uv) {
+        let glint = if q.foil == Foil::None {
+            None
+        } else {
+            self.glint
+        };
+        let overlay = match (glint.is_some(), q.translucent) {
+            (false, true) => crate::gfx::TRANSLUCENT_ITEM_OVERLAY,
+            (false, false) => 0,
+            (true, true) => crate::gfx::TRANSLUCENT_GLINT_ITEM_OVERLAY,
+            (true, false) => 7,
+        };
+        for (i, (p, uv)) in q.pos.iter().zip(q.uv).enumerate() {
+            let glint_uv = glint.map_or([0.0, 0.0], |glint| glint.uv(q.foil_uv[i]));
             self.out.push(Vertex {
                 normal: [0; 4],
                 pos: p.to_array(),
@@ -702,6 +793,7 @@ impl ItemSink for WorldSink<'_> {
                 layer: overlay,
                 color,
                 light,
+                glint_uv,
             });
         }
     }
@@ -758,6 +850,33 @@ pub fn cluster_poses(state: &ItemRenderState, pose: Mat4, amount: u32, seed: i64
 mod tests {
     use super::*;
 
+    /// A bad item model surfaces only once items.json has loaded, so a broken
+    /// items.json still reports itself first.
+    #[test]
+    fn item_model_errors_wait_for_the_item_definitions() -> crate::Result<()> {
+        let root =
+            std::env::temp_dir().join(format!("horizon-item-model-errors-{}", std::process::id()));
+        let model = root.join("assets/horizon/models/INVALID.json");
+        fs::create_dir_all(model.parent().unwrap())?;
+        fs::write(model, "{}")?;
+        let library = crate::model_library::ParsedModels::load(&root).into_item_library();
+        assert!(library.is_err());
+        fs::write(root.join("items.json"), "{")?;
+        let load = || {
+            ItemRenderer::load_with_library(&root, library.clone())
+                .err()
+                .unwrap()
+                .to_string()
+        };
+        let broken_items = load();
+        fs::write(root.join("items.json"), "{}")?;
+        let bad_model = load();
+        let _ = fs::remove_dir_all(&root);
+        assert!(!broken_items.starts_with("item models:"));
+        assert!(bad_model.starts_with("item models:"));
+        Ok(())
+    }
+
     #[test]
     fn rendered_amounts_follow_the_count_bands() {
         let bands: Vec<u32> = [0, 1, 2, 16, 17, 32, 33, 48, 49, 64]
diff --git a/crates/horizon-client/src/item_render/gui.rs b/crates/horizon-client/src/item_render/gui.rs
index ff25fff1d..a99969679 100644
--- a/crates/horizon-client/src/item_render/gui.rs
+++ b/crates/horizon-client/src/item_render/gui.rs
@@ -5,7 +5,7 @@
 //! drawn far to near, and clipped to the item's 16x16 slot unless the model
 //! is oversized in the GUI (`GuiItemAtlas` draws each item into a scissored
 //! 16x16 slot; oversized items get a picture-in-picture of their bounds).
-use super::{Foil, ItemQuad, ItemRenderState, ItemRenderer, SpecialHost};
+use super::{Foil, Glint, ItemQuad, ItemRenderState, ItemRenderer, SpecialHost};
 use crate::hud::{HudBatch, Rect};
 use glam::{EulerRot, Mat4, Vec2, Vec3};
 use std::{collections::HashMap, f32::consts::PI, sync::Arc};
@@ -43,6 +43,7 @@ pub fn items_3d_lights() -> (Vec3, Vec3) {
 struct Point {
     p: Vec2,
     uv: [f32; 2],
+    glint_uv: [f32; 2],
 }
 fn lerp(a: Point, b: Point, t: f32) -> Point {
     Point {
@@ -51,6 +52,10 @@ fn lerp(a: Point, b: Point, t: f32) -> Point {
             a.uv[0] + (b.uv[0] - a.uv[0]) * t,
             a.uv[1] + (b.uv[1] - a.uv[1]) * t,
         ],
+        glint_uv: [
+            a.glint_uv[0] + (b.glint_uv[0] - a.glint_uv[0]) * t,
+            a.glint_uv[1] + (b.glint_uv[1] - a.glint_uv[1]) * t,
+        ],
     }
 }
 /// Sutherland-Hodgman against one half plane `dot(p, n) <= limit`.
@@ -97,37 +102,25 @@ pub fn lit_color(q: &ItemQuad, lights: (Vec3, Vec3)) -> u32 {
     let c = |v: u8| (f32::from(v) * light) as u8;
     crate::hud::rgba(c(r), c(g), c(b), a)
 }
-/// The glint's moving sheen at a GUI position (a stand-in for the
-/// `GLINT_TEXTURING`-scrolled `enchanted_glint_item` texture added on top).
-fn glint_color(p: Vec2, time: f32) -> u32 {
-    let d = ((p.x + p.y) / 32.0 - time * 0.35).rem_euclid(1.0);
-    let band = (1.0 - (d - 0.5).abs() * 6.0).max(0.0);
-    crate::hud::rgba(
-        (170.0 + 70.0 * band) as u8,
-        (90.0 + 110.0 * band) as u8,
-        255,
-        (45.0 + 110.0 * band) as u8,
-    )
-}
-
-fn emit(batch: &mut HudBatch, fan: &[Point], color: impl Fn(Vec2) -> u32, glint: bool) {
-    let shift = if glint { 2.0 } else { 0.0 };
+fn emit(batch: &mut HudBatch, fan: &[Point], color: impl Fn(Vec2) -> u32, glint: Option<&Glint>) {
     for i in 1..fan.len().saturating_sub(1) {
         let (a, b, c) = (fan[0], fan[i], fan[i + 1]);
         let corners = [a, b, c, c];
-        // `HudBatch.quad` draws (0, 1, 2) and (0, 2, 3): the second is empty.
-        batch.quad(
-            corners.map(|v| v.p.to_array()),
-            corners.map(|v| [v.uv[0] + shift, v.uv[1]]),
-            color(a.p),
-        );
-        if glint {
-            // Per-vertex colours are flat per quad in the HUD batch: use the
-            // fan centre for the sheen.
-            let n = batch.vertices.len();
-            for v in &mut batch.vertices[n - 6..] {
-                v.color = color(Vec2::from(v.pos));
-            }
+        if let Some(glint) = glint {
+            let start = batch.vertices.len();
+            batch.quad_glint(
+                corners.map(|v| v.p.to_array()),
+                corners.map(|v| [v.uv[0] + 2.0, v.uv[1]]),
+                corners.map(|v| glint.uv(v.glint_uv)),
+                u32::MAX,
+            );
+            batch.blend_since(start, crate::hud::Blend::Additive);
+        } else {
+            batch.quad(
+                corners.map(|v| v.p.to_array()),
+                corners.map(|v| v.uv),
+                color(a.p),
+            );
         }
     }
 }
@@ -144,6 +137,8 @@ pub fn draw(
     x: f32,
     y: f32,
     time: f32,
+    glint_speed: f32,
+    glint_alpha: f32,
 ) {
     if state.is_empty() {
         return;
@@ -162,7 +157,18 @@ pub fn draw(
         return;
     }
     let start = batch.vertices.len();
-    draw_now(state, renderer, sprites, host, batch, x, y, time);
+    draw_now(
+        state,
+        renderer,
+        sprites,
+        host,
+        batch,
+        x,
+        y,
+        time,
+        glint_speed,
+        glint_alpha,
+    );
     if let Some(key) = key
         && let Ok(mut drawn) = renderer.gui_drawn.lock()
     {
@@ -236,6 +242,8 @@ fn draw_now(
     x: f32,
     y: f32,
     time: f32,
+    glint_speed: f32,
+    glint_alpha: f32,
 ) {
     let pose = Mat4::from_translation(Vec3::new(x + 8.0, y + 8.0, 0.0))
         * Mat4::from_scale(Vec3::new(16.0, -16.0, 16.0));
@@ -256,7 +264,16 @@ fn draw_now(
     } else {
         [x, y, x + 16.0, y + 16.0]
     };
-    draw_quads(&quads, lights, batch, rect, time);
+    let glint = sprites
+        .contains_key("misc/enchanted_glint_item")
+        .then_some(Glint {
+            speed: glint_speed,
+            alpha: glint_alpha,
+            millis: time * 1000.0,
+            scale: 8.0,
+        });
+    batch.glint_alpha = glint_alpha;
+    draw_quads(&quads, lights, batch, rect, glint.as_ref());
 }
 
 /// Lights, culls, sorts far to near and clips `quads` (GUI positions) to
@@ -266,7 +283,7 @@ fn draw_quads(
     lights: (Vec3, Vec3),
     batch: &mut HudBatch,
     rect: [f32; 4],
-    time: f32,
+    glint: Option<&Glint>,
 ) {
     for face in depth::sort(quads) {
         let q = &quads[face.quad];
@@ -276,6 +293,7 @@ fn draw_quads(
             .map(|v| Point {
                 p: v.pos.truncate(),
                 uv: v.uv,
+                glint_uv: v.glint_uv,
             })
             .collect();
         let color = lit_color(q, lights);
@@ -285,9 +303,9 @@ fn draw_quads(
             if fan.len() < 3 {
                 continue;
             }
-            emit(batch, &fan, |_| color, false);
+            emit(batch, &fan, |_| color, None);
             if q.foil != Foil::None {
-                emit(batch, &fan, |p| glint_color(p, time), true);
+                emit(batch, &fan, |_| color, glint);
             }
         }
     }
@@ -342,7 +360,7 @@ pub fn draw_banner_result(
         items_flat_lights(),
         batch,
         [x0, y0, x0 + 20.0, y0 + 40.0],
-        0.0,
+        None,
     );
 }
 
@@ -354,10 +372,12 @@ mod tests {
         ItemQuad {
             pos: [(0.0, y0), (0.0, y1), (8.0, y1), (8.0, y0)].map(|(x, y)| Vec3::new(x, y, z(y))),
             uv: [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]],
+            foil_uv: [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]],
             normal: Vec3::Z,
             color,
             foil: Foil::None,
             light_emission: 0,
+            translucent: false,
         }
     }
 
@@ -394,7 +414,7 @@ mod tests {
             (Vec3::Z, Vec3::Z),
             &mut batch,
             [0.0, 0.0, 16.0, 16.0],
-            0.0,
+            None,
         );
         assert_eq!(color_at(&batch, Vec2::new(4.0, 0.5)), Some(u32::MAX));
     }
@@ -410,7 +430,7 @@ mod tests {
                 (Vec3::Z, Vec3::Z),
                 &mut batch,
                 [0.0, 0.0, 16.0, 16.0],
-                0.0,
+                None,
             );
             assert_eq!(
                 color_at(&batch, Vec2::new(4.0, 2.0)),
@@ -442,7 +462,7 @@ mod tests {
             (Vec3::Z, Vec3::Z),
             &mut batch,
             [0.0, 0.0, 16.0, 16.0],
-            0.0,
+            None,
         );
         for y in [0.5, 6.0] {
             assert_eq!(
@@ -468,6 +488,7 @@ mod tests {
         let p = |x: f32, y: f32| Point {
             p: Vec2::new(x, y),
             uv: [x, y],
+            glint_uv: [0.0, 0.0],
         };
         let fan = clip_triangle(
             [p(-4.0, 0.0), p(8.0, 0.0), p(8.0, 8.0)],
diff --git a/crates/horizon-client/src/item_render/gui/depth.rs b/crates/horizon-client/src/item_render/gui/depth.rs
index 9fecfdee7..aaaa0c55d 100644
--- a/crates/horizon-client/src/item_render/gui/depth.rs
+++ b/crates/horizon-client/src/item_render/gui/depth.rs
@@ -10,6 +10,7 @@ use glam::{Vec3, Vec4};
 pub(super) struct Corner {
     pub pos: Vec3,
     pub uv: [f32; 2],
+    pub glint_uv: [f32; 2],
 }
 
 pub(super) struct Face {
@@ -38,6 +39,9 @@ fn split(face: Face, distances: &[f32]) -> (Face, Face) {
             let corner = Corner {
                 pos: a.pos.lerp(b.pos, t),
                 uv: std::array::from_fn(|k| a.uv[k] + (b.uv[k] - a.uv[k]) * t),
+                glint_uv: std::array::from_fn(|k| {
+                    a.glint_uv[k] + (b.glint_uv[k] - a.glint_uv[k]) * t
+                }),
             };
             back.push(corner);
             front.push(corner);
@@ -73,6 +77,7 @@ pub(super) fn sort(quads: &[ItemQuad]) -> Vec<Face> {
                 corners: std::array::from_fn::<_, 4, _>(|k| Corner {
                     pos: q.pos[k],
                     uv: q.uv[k],
+                    glint_uv: q.foil_uv[k],
                 })
                 .to_vec(),
             })
diff --git a/crates/horizon-client/src/item_render/special.rs b/crates/horizon-client/src/item_render/special.rs
index d42378db1..6a1d049af 100644
--- a/crates/horizon-client/src/item_render/special.rs
+++ b/crates/horizon-client/src/item_render/special.rs
@@ -115,10 +115,12 @@ fn draw(
                     sprite.v0 + (sprite.v1 - sprite.v0) * v[4],
                 ]
             }),
+            foil_uv: poly.map(|v| [v[3], v[4]]),
             normal,
             color,
             foil,
             light_emission: 0,
+            translucent: false,
         });
     }
     for (child_name, child) in &part.children {
@@ -498,7 +500,7 @@ pub(super) fn submit(
             let skin = (!argument.is_null())
                 .then(|| host.player_skin(argument))
                 .flatten()
-                .unwrap_or_else(|| "entity/player/wide/steve".to_owned());
+                .unwrap_or_else(|| "entity/player/slim/steve".to_owned());
             part("player", &none, &skin, white, Foil::None);
         }
         SpecialKind::Trident => {
diff --git a/crates/horizon-client/src/item_sync.rs b/crates/horizon-client/src/item_sync.rs
index fc35e15e7..01d90246f 100644
--- a/crates/horizon-client/src/item_sync.rs
+++ b/crates/horizon-client/src/item_sync.rs
@@ -229,6 +229,17 @@ fn profile_tag(p: &Profile) -> Tag {
     if let Some(name) = &p.name {
         entries.push(("name", Tag::String(name.as_str().into())));
     }
+    if let Some(id) = p.id {
+        entries.push((
+            "id",
+            Tag::IntArray(vec![
+                (id >> 96) as i32,
+                (id >> 64) as i32,
+                (id >> 32) as i32,
+                id as i32,
+            ]),
+        ));
+    }
     entries.push(("properties", Tag::List(properties)));
     Tag::compound(entries)
 }
diff --git a/crates/horizon-client/src/item_tooltip.rs b/crates/horizon-client/src/item_tooltip.rs
index 88f01439e..63a19b114 100644
--- a/crates/horizon-client/src/item_tooltip.rs
+++ b/crates/horizon-client/src/item_tooltip.rs
@@ -108,6 +108,32 @@ fn modifier_line(
     )
 }
 
+/// `Attribute.getStyle`: the colour of a line for an attribute whose value
+/// rises or falls. Gravity, scale and the waypoint ranges are neutral, burning
+/// time and fall damage are negative, every other attribute is positive.
+fn attribute_color(attribute: &str, rises: bool) -> u32 {
+    let (blue, red) = (rgba(85, 85, 255, 255), rgba(255, 85, 85, 255));
+    match attribute {
+        "burning_time" | "fall_damage_multiplier" => {
+            if rises {
+                red
+            } else {
+                blue
+            }
+        }
+        "gravity" | "scale" | "waypoint_transmit_range" | "waypoint_receive_range" => {
+            rgba(170, 170, 170, 255)
+        }
+        _ => {
+            if rises {
+                blue
+            } else {
+                red
+            }
+        }
+    }
+}
+
 /// `ItemStack.addAttributeTooltips`: slot groups, colors and optional player
 /// attack damage/speed bases. Recipe search has no player context.
 pub fn attribute_lines(
@@ -150,10 +176,8 @@ pub fn attribute_lines(
             ) {
                 let (line, color) = if base.is_some() {
                     (format!(" {line}"), rgba(0, 170, 0, 255))
-                } else if *amount > 0.0 {
-                    (line, rgba(85, 85, 255, 255))
                 } else {
-                    (line, rgba(255, 85, 85, 255))
+                    (line, attribute_color(path, *amount > 0.0))
                 };
                 lines.push((line, color));
             }
@@ -231,6 +255,235 @@ pub fn rarity<'a>(stack: &ItemStack, default: &'a str) -> &'a str {
     }
 }
 
+fn is_beehive(path: &str) -> bool {
+    matches!(path, "beehive" | "bee_nest")
+}
+
+/// `InstrumentComponent.addToTooltip`: the instrument's description. A goat
+/// horn without the component has the item's default, the ponder horn.
+pub fn instrument_line(
+    stack: &ItemStack,
+    display: &TooltipDisplay,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Option<String> {
+    if !display.shows("minecraft:instrument") {
+        return None;
+    }
+    let id = match stack.data().and_then(|d| d.other("minecraft:instrument")) {
+        Some(Tag::String(id)) => id.to_string_lossy(),
+        // An inline instrument carries its own description.
+        Some(inline) => {
+            return inline
+                .get("description")
+                .map(|d| crate::entity_nbt::name_text(d).plain());
+        }
+        None if &*stack.item == "minecraft:goat_horn" => "minecraft:ponder_goat_horn".to_owned(),
+        None => return None,
+    };
+    let key = format!("instrument.{}", id.replacen(':', ".", 1));
+    Some(translate(&key).unwrap_or(key))
+}
+
+/// `Bees.addToTooltip`: how many bees a hive item holds (a hive item without
+/// the component has the item's default, none).
+pub fn bees_line(
+    stack: &ItemStack,
+    display: &TooltipDisplay,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Option<String> {
+    if !display.shows("minecraft:bees") {
+        return None;
+    }
+    let bees = match stack.data().and_then(|d| d.other("minecraft:bees")) {
+        Some(Tag::List(bees)) => bees.len(),
+        Some(_) => return None,
+        None if is_beehive(stack.item.trim_start_matches("minecraft:")) => 0,
+        None => return None,
+    };
+    let text =
+        translate("container.beehive.bees").unwrap_or_else(|| "container.beehive.bees".into());
+    Some(
+        text.replacen("%s", &bees.to_string(), 1)
+            .replacen("%s", "3", 1),
+    )
+}
+
+/// `BlockItemStateProperties.addToTooltip`: a hive item's honey level (a hive
+/// item without the component has the item's default, 0).
+pub fn honey_line(
+    stack: &ItemStack,
+    display: &TooltipDisplay,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Option<String> {
+    if !display.shows("minecraft:block_state") {
+        return None;
+    }
+    let level = match stack.data().and_then(|d| d.other("minecraft:block_state")) {
+        Some(Tag::Compound(state)) => {
+            match state.get(&horizon_world::nbt::JavaString::from("honey_level")) {
+                Some(Tag::String(level)) => level.to_string_lossy().parse::<u32>().ok()?,
+                _ => return None,
+            }
+        }
+        Some(_) => return None,
+        None if is_beehive(stack.item.trim_start_matches("minecraft:")) => 0,
+        None => return None,
+    };
+    let text =
+        translate("container.beehive.honey").unwrap_or_else(|| "container.beehive.honey".into());
+    Some(
+        text.replacen("%s", &level.to_string(), 1)
+            .replacen("%s", "5", 1),
+    )
+}
+
+/// `WrittenBookContent.addToTooltip`: "by <author>" and the generation.
+pub fn written_book_lines(
+    stack: &ItemStack,
+    display: &TooltipDisplay,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Vec<String> {
+    let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned());
+    let Some(book) = stack
+        .data()
+        .and_then(|d| d.written.as_ref())
+        .filter(|_| display.shows("minecraft:written_book_content"))
+    else {
+        return Vec::new();
+    };
+    let mut lines = Vec::new();
+    if !book.author.trim().is_empty() {
+        lines.push(
+            crate::text::format_translation(
+                &text("book.byAuthor"),
+                &[crate::text::Text::literal(&book.author)],
+            )
+            .plain(),
+        );
+    }
+    lines.push(text(&format!("book.generation.{}", book.generation)));
+    lines
+}
+
+/// `JukeboxPlayable.addToTooltip`: the song's description.
+pub fn jukebox_line(
+    stack: &ItemStack,
+    info: Option<&ItemInfo>,
+    display: &TooltipDisplay,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Option<String> {
+    if !display.shows("minecraft:jukebox_playable") {
+        return None;
+    }
+    let song = match stack
+        .data()
+        .and_then(|d| d.other("minecraft:jukebox_playable"))
+    {
+        Some(Tag::String(song)) => song.to_string_lossy(),
+        // An inline song carries its own description.
+        Some(inline) => {
+            return inline
+                .get("description")
+                .map(|d| crate::entity_nbt::name_text(d).plain());
+        }
+        None => info?.jukebox_song.clone()?,
+    };
+    let key = format!("jukebox_song.{}", song.replacen(':', ".", 1));
+    Some(translate(&key).unwrap_or(key))
+}
+
+/// `DyedItemColor.addToTooltip`: "Dyed" (italic, the flag), or with advanced
+/// tooltips the colour's hex code.
+pub fn dyed_line(
+    stack: &ItemStack,
+    display: &TooltipDisplay,
+    advanced: bool,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Option<(String, bool)> {
+    let rgb = stack.data()?.dyed_color?;
+    if !display.shows("minecraft:dyed_color") {
+        return None;
+    }
+    let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned());
+    Some(if advanced {
+        let hex = format!("#{:06X}", rgb & 0xFF_FFFF);
+        (text("item.color").replacen("%s", &hex, 1), false)
+    } else {
+        (text("item.dyed"), true)
+    })
+}
+
+/// `ItemStack.UNBREAKABLE_TOOLTIP`.
+pub fn unbreakable_line(
+    stack: &ItemStack,
+    display: &TooltipDisplay,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Option<String> {
+    (stack.data()?.other("minecraft:unbreakable").is_some()
+        && display.shows("minecraft:unbreakable"))
+    .then(|| translate("item.unbreakable").unwrap_or_else(|| "item.unbreakable".into()))
+}
+
+/// `PotionContents.addPotionTooltip`'s attribute block: an empty line, "When
+/// Applied:" and the modifiers of the potion's effects (blue for a gain, red
+/// for a loss); nothing for a potion whose effects add none.
+pub fn potion_modifier_lines(
+    stack: &ItemStack,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Vec<(String, u32)> {
+    if !is_potion_item(&stack.item) {
+        return Vec::new();
+    }
+    let applied: Vec<(String, u32)> = stack
+        .potion()
+        .and_then(crate::brewing::potion)
+        .into_iter()
+        .flat_map(|p| p.effects.iter())
+        .filter_map(|(effect, _, amplifier)| {
+            let (attribute, amount, operation) = effect_modifier(effect)?;
+            let amount = amount * (*amplifier + 1) as f64;
+            let line = modifier_line(translate, attribute, amount, operation, false)?;
+            let color = if amount > 0.0 {
+                rgba(85, 85, 255, 255)
+            } else {
+                rgba(255, 85, 85, 255)
+            };
+            Some((line, color))
+        })
+        .collect();
+    if applied.is_empty() {
+        return applied;
+    }
+    let mut lines = vec![
+        (String::new(), u32::MAX),
+        (
+            translate("potion.whenDrank").unwrap_or_else(|| "potion.whenDrank".into()),
+            rgba(170, 0, 170, 255),
+        ),
+    ];
+    lines.extend(applied);
+    lines
+}
+
+/// `ItemStack.components.size()`: the item's default components with the
+/// stack's own changes applied.
+pub fn component_count(stack: &ItemStack, info: Option<&ItemInfo>) -> usize {
+    let mut keys: std::collections::HashSet<String> = info
+        .map(|i| i.components.iter().cloned().collect())
+        .unwrap_or_default();
+    if let Some(Tag::Compound(patch)) = crate::item_data::components_tag(stack.damage, stack.data())
+    {
+        for key in patch.keys() {
+            let key = key.to_string_lossy();
+            match key.strip_prefix('!') {
+                Some(removed) => keys.remove(removed),
+                None => keys.insert(key),
+            };
+        }
+    }
+    keys.len()
+}
+
 /// The lines of `stack` below its name that its components give, in
 /// `ItemStack.addDetailsToTooltip` order.
 pub fn detail_lines(
@@ -265,19 +518,9 @@ pub fn detail_lines(
             ))
         ));
     }
-    // BeehiveBlock: the block state components of the item.
-    if path == "beehive" {
-        lines.push(
-            text("container.beehive.bees")
-                .replacen("%s", "0", 1)
-                .replacen("%s", "3", 1),
-        );
-        lines.push(
-            text("container.beehive.honey")
-                .replacen("%s", "0", 1)
-                .replacen("%s", "5", 1),
-        );
-    }
+    let display = TooltipDisplay::for_stack(stack);
+    lines.extend(bees_line(stack, &display, translate));
+    lines.extend(honey_line(stack, &display, translate));
     let data = stack.data();
     // PotDecorations.addToTooltip.
     if let Some(sherds) = data
@@ -303,32 +546,13 @@ pub fn detail_lines(
                 .into_iter()
                 .map(|l| l.0),
         );
-        let applied: Vec<String> = stack
-            .potion()
-            .and_then(crate::brewing::potion)
-            .into_iter()
-            .flat_map(|p| p.effects.iter())
-            .filter_map(|(effect, _, amplifier)| {
-                let (attribute, amount, operation) = effect_modifier(effect)?;
-                modifier_line(
-                    translate,
-                    attribute,
-                    amount * (*amplifier + 1) as f64,
-                    operation,
-                    false,
-                )
-            })
-            .collect();
-        if !applied.is_empty() {
-            lines.push(String::new());
-            lines.push(text("potion.whenDrank"));
-            lines.extend(applied);
-        }
-    }
-    // JukeboxPlayable.addToTooltip: the song's description.
-    if path.starts_with("music_disc_") {
-        lines.push(text(&format!("item.minecraft.{path}.desc")));
+        lines.extend(
+            potion_modifier_lines(stack, translate)
+                .into_iter()
+                .map(|l| l.0),
+        );
     }
+    lines.extend(jukebox_line(stack, info, &display, translate));
     // Trim.addToTooltip.
     if let Some((material, pattern)) = data.and_then(|d| d.trim.as_ref()) {
         let short = |s: &str| s.trim_start_matches("minecraft:").to_owned();
@@ -342,10 +566,7 @@ pub fn detail_lines(
             text(&format!("trim_material.minecraft.{}", short(material)))
         ));
     }
-    // DyedItemColor.addToTooltip (without advanced tooltips).
-    if data.is_some_and(|d| d.dyed_color.is_some()) {
-        lines.push(text("item.dyed"));
-    }
+    lines.extend(dyed_line(stack, &display, false, translate).map(|l| l.0));
     if let Some(info) = info {
         lines.extend(
             attribute_lines(&info.modifiers, None, translate)
diff --git a/crates/horizon-client/src/items.rs b/crates/horizon-client/src/items.rs
index b4092a201..10f1c72ad 100644
--- a/crates/horizon-client/src/items.rs
+++ b/crates/horizon-client/src/items.rs
@@ -113,6 +113,9 @@ pub struct ItemInfo {
     pub swappable: bool,
     /// `equippable.dispensable` (dispensers may put it on an entity).
     pub equip_dispensable: bool,
+    /// `equippable.damage_on_hurt`: the item wears when its wearer is hurt
+    /// (false for the elytra).
+    pub equip_damage_on_hurt: bool,
     /// `equippable.allowed_entities` resolved to entity type ids; None allows all.
     pub equip_allowed: Option<HashSet<String>>,
     pub equip_sound: Option<String>,
@@ -128,6 +131,8 @@ pub struct ItemInfo {
     pub block_transformer: Option<String>,
     /// Has a default `bundle_contents` (the bundles, `BundleItem`).
     pub bundle: bool,
+    /// The ids of the item's default components (its prototype's keys).
+    pub components: Vec<String>,
 }
 /// `Item.Properties.craftRemainder` (not a data component, so not in the
 /// default-component report): what an item leaves in the grid when crafted with.
@@ -400,6 +405,36 @@ impl Items {
         self.get(&stack.item).is_some_and(|i| i.fire_resistant)
     }
 
+    /// `ItemStack.canBeHurtBy` for the cactus damage type: a `damage_resistant`
+    /// component naming `minecraft:cactus`, or a damage type tag that holds it.
+    /// (`#minecraft:is_fire`, as on netherite gear, does not.)
+    pub fn resists_cactus(&self, stack: &ItemStack) -> bool {
+        const CACTUS_TAGS: [&str; 5] = [
+            "#minecraft:bypasses_shield",
+            "#minecraft:no_knockback",
+            "#minecraft:panic_environmental_causes",
+            "#minecraft:panic_causes",
+            "#minecraft:sulfur_cube_with_block_immune_to",
+        ];
+        let Some((_, v)) = stack.data().and_then(|data| {
+            data.other
+                .iter()
+                .find(|(key, _)| key == "minecraft:damage_resistant")
+        }) else {
+            return false;
+        };
+        match v.get("types") {
+            Some(horizon_world::nbt::Tag::String(id)) => id
+                .to_string()
+                .is_ok_and(|id| id == "minecraft:cactus" || CACTUS_TAGS.contains(&id.as_str())),
+            Some(horizon_world::nbt::Tag::List(ids)) => ids.iter().any(|t| {
+                matches!(t, horizon_world::nbt::Tag::String(id)
+                    if id.to_string().is_ok_and(|id| id == "minecraft:cactus"))
+            }),
+            _ => false,
+        }
+    }
+
     pub fn load(root: &Path, registry: &BlockRegistry, facts: &BlockFacts) -> Result<Self> {
         let mut block_for_item: HashMap<&str, BlockStateId> = HashMap::new();
         for (i, s) in facts.states.iter().enumerate() {
@@ -596,6 +631,9 @@ impl Items {
                     equip_dispensable: c["minecraft:equippable"]["dispensable"]
                         .as_bool()
                         .unwrap_or(true),
+                    equip_damage_on_hurt: c["minecraft:equippable"]["damage_on_hurt"]
+                        .as_bool()
+                        .unwrap_or(true),
                     equip_allowed: match &c["minecraft:equippable"]["allowed_entities"] {
                         Value::String(spec) => Some(entity_spec(&entity_tags, spec)),
                         Value::Array(list) => Some(
@@ -614,6 +652,10 @@ impl Items {
                     cushion_color: c["minecraft:cushion/color"].as_str().map(str::to_owned),
                     block_transformer: c["minecraft:block_transformer"].as_str().map(str::to_owned),
                     bundle: c.get("minecraft:bundle_contents").is_some(),
+                    components: c
+                        .as_object()
+                        .map(|c| c.keys().cloned().collect())
+                        .unwrap_or_default(),
                     crafting_remainder: CRAFT_REMAINDERS
                         .iter()
                         .find(|(item, _)| *item == name)
@@ -834,6 +876,7 @@ impl Items {
             held: None,
             killed_by_player: false,
             explosion_radius: None,
+            this_entity: false,
         };
         ctx.evaluate(table, random)
     }
@@ -898,10 +941,26 @@ impl Items {
         random: &mut impl RandomSource,
         sequences: Option<(&mut crate::random_sequences::RandomSequences, i64)>,
     ) -> Vec<ItemStack> {
-        self.block_drops_exploded(registry, state, held, dynamic, random, sequences, None)
+        self.block_drops_exploded(
+            registry, state, held, dynamic, random, sequences, None, false,
+        )
+    }
+    /// `block_drops_with` for a block a player breaks (`Block.playerDestroy`):
+    /// the player is the loot context's `this` entity, so snow and chorus
+    /// flower tables see an entity.
+    pub fn block_drops_by_player(
+        &self,
+        registry: &BlockRegistry,
+        state: BlockStateId,
+        held: Option<&ItemStack>,
+        dynamic: &[ItemStack],
+        random: &mut impl RandomSource,
+    ) -> Vec<ItemStack> {
+        self.block_drops_exploded(registry, state, held, dynamic, random, None, None, true)
     }
     /// `block_drops_full` for a block an explosion destroys: `explosion`
-    /// is its radius when the explosion decays drops (`DESTROY_WITH_DECAY`).
+    /// is its radius when the explosion decays drops (`DESTROY_WITH_DECAY`);
+    /// `breaker` is whether an entity (the player) broke the block.
     #[allow(clippy::too_many_arguments)]
     pub fn block_drops_exploded(
         &self,
@@ -912,8 +971,10 @@ impl Items {
         random: &mut impl RandomSource,
         sequences: Option<(&mut crate::random_sequences::RandomSequences, i64)>,
         explosion: Option<f32>,
+        breaker: bool,
     ) -> Vec<ItemStack> {
-        let drops = self.block_drops_raw(registry, state, held, random, sequences, explosion);
+        let drops =
+            self.block_drops_raw(registry, state, held, random, sequences, explosion, breaker);
         if !drops.iter().any(|d| d.item.starts_with(DYNAMIC)) {
             return drops;
         }
@@ -928,6 +989,7 @@ impl Items {
             })
             .collect()
     }
+    #[allow(clippy::too_many_arguments)]
     fn block_drops_raw(
         &self,
         registry: &BlockRegistry,
@@ -936,6 +998,7 @@ impl Items {
         random: &mut impl RandomSource,
         sequences: Option<(&mut crate::random_sequences::RandomSequences, i64)>,
         explosion_radius: Option<f32>,
+        breaker: bool,
     ) -> Vec<ItemStack> {
         let Some(block) = registry.state(state) else {
             return vec![];
@@ -969,6 +1032,7 @@ impl Items {
                 held,
                 killed_by_player: false,
                 explosion_radius,
+                this_entity: breaker,
             };
             return ctx.evaluate(table, random);
         }
@@ -979,6 +1043,7 @@ impl Items {
             held,
             killed_by_player: false,
             explosion_radius,
+            this_entity: breaker,
         };
         ctx.evaluate(table, random)
     }
@@ -1002,6 +1067,7 @@ impl Items {
             held,
             killed_by_player,
             explosion_radius: None,
+            this_entity: false,
         };
         ctx.evaluate(table, random)
     }
@@ -1034,6 +1100,7 @@ impl Items {
             held: None,
             killed_by_player: false,
             explosion_radius: None,
+            this_entity: false,
         };
         match table.get("random_sequence").and_then(Value::as_str) {
             Some(sequence) => ctx.evaluate(table, sequences.get(sequence, seed)),
@@ -1059,6 +1126,7 @@ impl Items {
             held,
             killed_by_player,
             explosion_radius: None,
+            this_entity: false,
         };
         ctx.evaluate(table, random)
     }
@@ -1081,6 +1149,7 @@ impl Items {
             held,
             killed_by_player,
             explosion_radius: None,
+            this_entity: false,
         };
         ctx.evaluate(table, random)
     }
@@ -1122,6 +1191,8 @@ struct LootContext<'a> {
     killed_by_player: bool,
     /// `LootContextParams.EXPLOSION_RADIUS`: an explosion that decays drops.
     explosion_radius: Option<f32>,
+    /// `LootContextParams.THIS_ENTITY` is set (a player broke the block).
+    this_entity: bool,
 }
 impl LootContext<'_> {
     /// Level of an enchantment on the tool / killer's weapon.
@@ -1282,6 +1353,15 @@ impl LootContext<'_> {
                 };
                 random.next_float() < chance
             }
+            // `this` with no checks (snow, chorus flower) holds when an entity
+            // broke the block (LootItemEntityPropertyCondition needs the entity).
+            "minecraft:entity_properties"
+                if self.this_entity
+                    && c["entity"].as_str() == Some("this")
+                    && c["predicate"].as_object().is_none_or(|p| p.is_empty()) =>
+            {
+                true
+            }
             // Entity flags, equipment and damage-source predicates: none hold
             // for an unenchanted player kill without fire or lightning.
             "minecraft:entity_properties" | "minecraft:damage_source_properties" => false,
@@ -1667,6 +1747,7 @@ mod tests {
             held,
             killed_by_player: block.is_empty(),
             explosion_radius: None,
+            this_entity: false,
         }
     }
 
diff --git a/crates/horizon-client/src/keybinds.rs b/crates/horizon-client/src/keybinds.rs
index 7575fb953..2047b9117 100644
--- a/crates/horizon-client/src/keybinds.rs
+++ b/crates/horizon-client/src/keybinds.rs
@@ -2,7 +2,6 @@
 //! defaults, `key_<name>:key.keyboard.x` persistence, display names, and the
 //! translation of rebound physical keys back to the default keys the game
 //! logic listens for.
-use crate::text::Text;
 use std::collections::BTreeMap;
 use winit::{event::MouseButton, keyboard::KeyCode};
 
@@ -225,40 +224,7 @@ pub fn mouse_button(name: &str) -> Option<MouseButton> {
         _ => return None,
     })
 }
-/// InputConstants.Key.getDisplayName: one-character keys as the upper-case
-/// character, others by translation.
-pub fn display_name(key: &str) -> Text {
-    if let Some(rest) = key.strip_prefix("key.keyboard.")
-        && rest.chars().count() == 1
-    {
-        let c = rest.to_uppercase();
-        return Text::literal(c);
-    }
-    let symbol = match key {
-        "key.keyboard.minus" => Some("-"),
-        "key.keyboard.equal" => Some("="),
-        "key.keyboard.left.bracket" => Some("["),
-        "key.keyboard.right.bracket" => Some("]"),
-        "key.keyboard.backslash" => Some("\\"),
-        "key.keyboard.semicolon" => Some(";"),
-        "key.keyboard.apostrophe" => Some("'"),
-        "key.keyboard.grave.accent" => Some("`"),
-        "key.keyboard.comma" => Some(","),
-        "key.keyboard.period" => Some("."),
-        "key.keyboard.slash" => Some("/"),
-        _ => None,
-    };
-    if let Some(s) = symbol {
-        return Text::literal(s);
-    }
-    if let Some(n) = key.strip_prefix("key.mouse.")
-        && n.parse::<u32>().is_ok()
-        && !crate::lang::has(key)
-    {
-        return Text::translate("key.mouse", &[Text::literal(n)]);
-    }
-    Text::translate(key, &[])
-}
+pub use horizon_client_core::key_display::display_name;
 
 /// Current bindings by mapping name.
 #[derive(Clone, Debug, PartialEq, Eq)]
diff --git a/crates/horizon-client/src/lan/chunks.rs b/crates/horizon-client/src/lan/chunks.rs
index 122d37bcd..9ca20b894 100644
--- a/crates/horizon-client/src/lan/chunks.rs
+++ b/crates/horizon-client/src/lan/chunks.rs
@@ -66,6 +66,7 @@ pub fn block_entity_type(name: &str) -> Option<&'static str> {
         "sculk_catalyst" => "minecraft:sculk_catalyst",
         "sculk_shrieker" => "minecraft:sculk_shrieker",
         "crafter" => "minecraft:crafter",
+        "potent_sulfur" => "minecraft:potent_sulfur",
         "chiseled_bookshelf" => "minecraft:chiseled_bookshelf",
         "trial_spawner" => "minecraft:trial_spawner",
         "vault" => "minecraft:vault",
diff --git a/crates/horizon-client/src/lan/commands.rs b/crates/horizon-client/src/lan/commands.rs
index 71b7fa68d..c3e462348 100644
--- a/crates/horizon-client/src/lan/commands.rs
+++ b/crates/horizon-client/src/lan/commands.rs
@@ -86,6 +86,18 @@ impl CommandTree {
 
     /// The ClientboundCommandsPacket for a player with `level` permissions.
     pub fn packet(&self, level: u8, dedicated: bool, builtin: &Builtin) -> Commands {
+        self.packet_with(level, dedicated, builtin, &Value::Null)
+    }
+
+    /// [`CommandTree::packet`] with more commands after vanilla's: `extra`
+    /// is a root in the report's format (server mods' commands).
+    pub fn packet_with(
+        &self,
+        level: u8,
+        dedicated: bool,
+        builtin: &Builtin,
+        extra: &Value,
+    ) -> Commands {
         let mut nodes = vec![Node {
             name: String::new(),
             kind: 0,
@@ -99,16 +111,18 @@ impl CommandTree {
         let suggestions: HashMap<&str, &'static str> = SUGGESTIONS.iter().copied().collect();
         let mut paths: HashMap<Vec<String>, usize> = HashMap::new();
         paths.insert(Vec::new(), 0);
-        fill(
-            &self.root,
-            0,
-            &mut Vec::new(),
-            level,
-            dedicated,
-            &suggestions,
-            &mut nodes,
-            &mut paths,
-        );
+        for root in [&self.root, extra] {
+            fill(
+                root,
+                0,
+                &mut Vec::new(),
+                level,
+                dedicated,
+                &suggestions,
+                &mut nodes,
+                &mut paths,
+            );
+        }
         // enumerateNodes: breadth first from the root, each node's children
         // (in registration order) then its redirect target.
         let mut ids = vec![None; nodes.len()];
@@ -365,4 +379,33 @@ mod tests {
         );
         assert!(op.nodes[3].restricted);
     }
+
+    #[test]
+    fn server_mods_commands_follow_vanillas() {
+        let report: Value = serde_json::from_str(
+            r#"{"type":"root","children":{"me":{"type":"literal","children":{"action":{"type":"argument","parser":"minecraft:message","executable":true}}}}}"#,
+        )
+        .unwrap();
+        let mods: Value = serde_json::from_str(
+            r#"{"type":"root","children":{"beacon":{"type":"literal","executable":true,"children":{
+                "height":{"type":"argument","parser":"brigadier:integer","properties":{"min":1,"max":64},"executable":true}}}}}"#,
+        )
+        .unwrap();
+        let tree = CommandTree { root: report };
+        let packet = tree.packet_with(0, true, &Builtin::default(), &mods);
+        let names: Vec<_> = packet.nodes.iter().map(|n| n.name.as_str()).collect();
+        assert_eq!(names, ["", "me", "beacon", "action", "height"]);
+        let beacon = &packet.nodes[2];
+        assert!(beacon.executable && !beacon.restricted);
+        assert_eq!(beacon.children, [4]);
+        let height = packet.nodes[4].parser.as_ref().unwrap();
+        assert_eq!(height.1, vec![3, 0, 0, 0, 1, 0, 0, 0, 64]);
+        // No mods: vanilla's tree as it is.
+        assert_eq!(
+            tree.packet_with(0, true, &Builtin::default(), &Value::Null)
+                .nodes
+                .len(),
+            3
+        );
+    }
 }
diff --git a/crates/horizon-client/src/lan/conn.rs b/crates/horizon-client/src/lan/conn.rs
index f2dcf701d..99b70e065 100644
--- a/crates/horizon-client/src/lan/conn.rs
+++ b/crates/horizon-client/src/lan/conn.rs
@@ -791,6 +791,16 @@ fn login_and_configure(
             },
         }),
     )?;
+    // ServerConfigurationPacketListenerImpl.startConfiguration: links, only
+    // when there are any (MinecraftServer.serverLinks is empty elsewhere).
+    if !shared.config.server_links.is_empty() {
+        send(
+            c,
+            cfg::Clientbound::ServerLinks(cfg::ServerLinks {
+                links: shared.config.server_links.clone(),
+            }),
+        )?;
+    }
     send(
         c,
         cfg::Clientbound::UpdateEnabledFeatures(cfg::UpdateEnabledFeatures {
diff --git a/crates/horizon-client/src/lan/containers.rs b/crates/horizon-client/src/lan/containers.rs
index 002f95cbb..59f01552e 100644
--- a/crates/horizon-client/src/lan/containers.rs
+++ b/crates/horizon-client/src/lan/containers.rs
@@ -36,6 +36,30 @@ impl Hub {
 
     /// ClientboundSoundPacket for a sound event name (an inline event when
     /// the registry does not know it).
+    pub fn sound_packet(
+        &self,
+        name: &str,
+        at: [f64; 3],
+        volume: f32,
+        pitch: f32,
+        source: i32,
+        seed: i64,
+    ) -> C {
+        let sound = match self.sync.id("minecraft:sound_event", name) {
+            Some(id) => (id, None),
+            None => (-1, Some((name.to_owned(), None))),
+        };
+        C::Sound(play::Sound {
+            sound,
+            source,
+            x: (at[0] * 8.0) as i32,
+            y: (at[1] * 8.0) as i32,
+            z: (at[2] * 8.0) as i32,
+            volume,
+            pitch,
+            seed,
+        })
+    }
     pub fn sound(
         &self,
         name: &str,
@@ -45,20 +69,7 @@ impl Hub {
         source: i32,
         except: Option<u32>,
     ) {
-        let sound = match self.sync.id("minecraft:sound_event", name) {
-            Some(id) => (id, None),
-            None => (-1, Some((name.to_owned(), None))),
-        };
-        let packet = C::Sound(play::Sound {
-            sound,
-            source,
-            x: (at[0] * 8.0) as i32,
-            y: (at[1] * 8.0) as i32,
-            z: (at[2] * 8.0) as i32,
-            volume,
-            pitch,
-            seed: self.ticks as i64,
-        });
+        let packet = self.sound_packet(name, at, volume, pitch, source, self.ticks as i64);
         self.broadcast_near(at, f64::from(volume.max(1.0)) * 16.0, &packet, except);
     }
 
@@ -120,12 +131,13 @@ impl Hub {
         );
     }
 
-    /// `ServerPlayer.crit`: send the victim's animation to the players tracking
-    /// the attacker and the attacker themselves (`sendToTrackingPlayersAndSelf`).
-    pub fn critical_hit(&self, attacker: i32, target: i32) {
+    /// `ServerPlayer.crit` (`magicCrit` when `magic`): send the victim's
+    /// animation to the players tracking the attacker and the attacker
+    /// themselves (`sendToTrackingPlayersAndSelf`).
+    pub fn critical_hit(&self, attacker: i32, target: i32, magic: bool) {
         let body = C::Animate(play::Animate {
             id: target,
-            action: 1,
+            action: if magic { 2 } else { 1 },
         })
         .encode();
         for g in self.guests.iter().filter(|g| {
@@ -421,6 +433,42 @@ impl Hub {
         drops
     }
 
+    /// `AbstractContainerMenu.setSelectedBundleItemIndex` on the guest's open
+    /// menu: a container's own slots, or the inventory's. A bundle's selection
+    /// lives on the server's stack until the click that takes from it.
+    pub fn select_bundle_item(&mut self, conn: u32, slot: usize, index: i32, world: &mut World) {
+        let Some(g) = self.guests.iter_mut().find(|g| g.conn == conn) else {
+            return;
+        };
+        let open = g.menu.as_ref().map(|m| (m.size, m.slots));
+        let mut items = match open {
+            Some((size, source)) if slot < size => source.read(world, g),
+            _ => None,
+        };
+        let stack = match open {
+            Some((size, _)) if slot < size => items
+                .as_mut()
+                .and_then(|items| items.get_mut(slot))
+                .and_then(Option::as_mut),
+            Some((size, _)) => g
+                .inventory
+                .get_mut(player_slot(slot - size))
+                .and_then(Option::as_mut),
+            None => match slot {
+                9..=35 => g.inventory.get_mut(slot).and_then(Option::as_mut),
+                36..=44 => g.inventory.get_mut(slot - 36).and_then(Option::as_mut),
+                45 => g.offhand.as_mut(),
+                _ => None,
+            },
+        };
+        if let Some(stack) = stack {
+            crate::bundle::toggle_selected(stack, index);
+        }
+        if let (Some((_, source)), Some(items)) = (open, items) {
+            source.write(world, g, items);
+        }
+    }
+
     /// A click on the inventory menu (window 0) the game applied itself
     /// (the crafting grid): the client is corrected like after any click.
     pub fn inventory_clicked(
diff --git a/crates/horizon-client/src/lan/entity.rs b/crates/horizon-client/src/lan/entity.rs
index ae3089006..920052b5a 100644
--- a/crates/horizon-client/src/lan/entity.rs
+++ b/crates/horizon-client/src/lan/entity.rs
@@ -611,8 +611,9 @@ pub struct Viewer<'a> {
 }
 
 /// One entity as this tick's range checks read it: where it is
-/// horizontally, its id, its type's tracking range in chunks and the chunk
-/// it is in (an index into the tick's chunks).
+/// horizontally, its id, its tracking range in blocks (scaled by
+/// `entity-broadcast-range-percentage`) and the chunk it is in (an index
+/// into the tick's chunks).
 #[derive(Clone, Copy)]
 struct Probe {
     x: f64,
@@ -627,7 +628,7 @@ struct Probe {
 /// each of the tick's chunks whether the client has it (0: not looked up
 /// yet, 1: no, 2: yes), so each chunk is looked up once per client.
 fn sees(v: &Viewer, p: &Probe, chunks: &[(i32, i32)], held: &mut [u8]) -> bool {
-    let range = f64::from(p.range.min(v.view_distance) * 16);
+    let range = f64::from(p.range.min(v.view_distance * 16));
     let (dx, dz) = (v.position[0] - p.x, v.position[2] - p.z);
     dx * dx + dz * dz <= range * range && {
         let held = &mut held[p.chunk as usize];
@@ -641,6 +642,9 @@ fn sees(v: &Viewer, p: &Probe, chunks: &[(i32, i32)], held: &mut [u8]) -> bool {
 /// One level's tracked entities (ChunkMap.entityMap).
 #[derive(Default)]
 pub struct Entities {
+    /// `entity-broadcast-range-percentage` (None: 100), which scales every
+    /// type's tracking range (MinecraftServer.getScaledTrackingDistance).
+    pub range_percent: Option<i32>,
     states: crate::fast_hash::FxHashMap<i32, ServerEntity>,
     /// The level tick, stamped on every entity still in the level.
     tick: u32,
@@ -732,7 +736,9 @@ impl Entities {
                 x: e.position[0],
                 z: e.position[2],
                 id: e.id,
-                range: s.range,
+                range: self
+                    .range_percent
+                    .map_or(s.range * 16, |p| p * (s.range * 16) / 100),
                 chunk,
             });
         }
diff --git a/crates/horizon-client/src/lan/guest.rs b/crates/horizon-client/src/lan/guest.rs
index 7e43cf04e..9f83e1457 100644
--- a/crates/horizon-client/src/lan/guest.rs
+++ b/crates/horizon-client/src/lan/guest.rs
@@ -2,7 +2,12 @@
 //! player state (inventory, health, game mode) that the host's gameplay code
 //! operates on when it acts for them.
 use super::{Joined, PlayerSender, entity::Tracker};
-use crate::{items::ItemStack, motion::PlayerMotion};
+use crate::{
+    items::ItemStack,
+    motion::PlayerMotion,
+    pose::{Dimensions, Pose},
+};
+use horizon_core::geometry::{Aabb, Vec3};
 use horizon_protocol::{
     item::Stack,
     packets::{configuration::ClientInformation, play},
@@ -407,8 +412,41 @@ impl Guest {
         }
         f
     }
+    /// `Player.getDesiredPose`: sleeping, gliding, then the body's own pose
+    /// (swimming, crawling, crouching) once its server tick has run.
+    pub fn pose(&self) -> Pose {
+        if self.sleeping {
+            Pose::Sleeping
+        } else if self.fall_flying {
+            Pose::FallFlying
+        } else if let Some(m) = &self.motion {
+            m.pose
+        } else if self.sneaking && !self.flying {
+            Pose::Crouching
+        } else {
+            Pose::Standing
+        }
+    }
+    /// `Avatar.POSES` for the guest's pose, with its scale attribute.
+    pub fn dimensions(&self) -> Dimensions {
+        let pose = self.pose();
+        match &self.motion {
+            Some(m) if m.pose == pose => m.dimensions,
+            _ => pose.dimensions(1.0),
+        }
+    }
+    /// `Entity.getBoundingBox`.
+    pub fn bounds(&self) -> Aabb {
+        let [x, y, z] = self.position;
+        let d = self.dimensions();
+        let half = f64::from(d.width) / 2.0;
+        Aabb::new(
+            Vec3::new(x - half, y, z - half),
+            Vec3::new(x + half, y + f64::from(d.height), z + half),
+        )
+    }
     pub fn eye_height(&self) -> f64 {
-        if self.sneaking { 1.27 } else { 1.62 }
+        f64::from(self.dimensions().eye_height)
     }
     /// `Player.isWithinBlockInteractionRange(pos, buffer)` for the guest:
     /// its block interaction range is 4.5, 5 in creative.
@@ -631,11 +669,14 @@ fn network_stack(
                         title: w.title.clone(),
                         author: w.author.clone(),
                         generation: i32::from(w.generation),
-                        pages: w
-                            .pages
-                            .iter()
-                            .map(|p| horizon_protocol::text::literal(p))
-                            .collect(),
+                        pages: if w.page_tags.len() == w.pages.len() {
+                            w.page_tags.clone()
+                        } else {
+                            w.pages
+                                .iter()
+                                .map(|p| horizon_protocol::text::literal(p))
+                                .collect()
+                        },
                         resolved: true,
                     },
                 ),
diff --git a/crates/horizon-client/src/lan/hub.rs b/crates/horizon-client/src/lan/hub.rs
index b1a8cbc62..12967d778 100644
--- a/crates/horizon-client/src/lan/hub.rs
+++ b/crates/horizon-client/src/lan/hub.rs
@@ -21,7 +21,7 @@ use crate::{
 use horizon_core::geometry::{Aabb, ShapeOp, Vec3, VoxelShape};
 use horizon_protocol::ids::play::clientbound as ids;
 use horizon_protocol::{
-    entity_data::{Value, serializer},
+    entity_data::{Particle, ParticleData, Value, serializer},
     packets::play::{self, Clientbound as C, Serverbound as S},
     text::{literal, translatable},
 };
@@ -43,6 +43,7 @@ pub mod game_event {
     pub const RAIN_LEVEL: u8 = 7;
     pub const THUNDER_LEVEL: u8 = 8;
     pub const GUARDIAN_ELDER_EFFECT: u8 = 10;
+    pub const IMMEDIATE_RESPAWN: u8 = 11;
     pub const LEVEL_CHUNKS_LOAD_START: u8 = 13;
 }
 
@@ -87,6 +88,29 @@ pub struct HostState {
     pub living_flags: i8,
     /// The bed the host sleeps in (`LivingEntity.SLEEPING_POS`).
     pub bed: Option<[i32; 3]>,
+    pub body: BodyFlags,
+}
+
+/// What the other players see of a player's body besides sneaking and
+/// sprinting: the pose and the rest of `Entity.DATA_SHARED_FLAGS_ID`.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct BodyFlags {
+    /// `Entity.isFallFlying`: gliding with elytra.
+    pub gliding: bool,
+    /// `Entity.isSwimming` (the swimming flag).
+    pub swimming: bool,
+    /// The swimming pose of a player crawling under a block.
+    pub crawling: bool,
+    /// The crouching pose, held without sneaking under a low ceiling.
+    pub crouching: bool,
+    /// `LivingEntity.isAutoSpinAttack`: Riptide's spin.
+    pub spin_attack: bool,
+    /// `Entity.isOnFire`.
+    pub on_fire: bool,
+    /// `Entity.isInvisible`: the invisibility effect.
+    pub invisible: bool,
+    /// The glowing effect.
+    pub glowing: bool,
 }
 
 /// Everything the hub needs from the game for one tick.
@@ -149,6 +173,8 @@ pub struct Hub {
     /// The `player_movement_check` and `elytra_movement_check` game rules,
     /// set by the game before each tick.
     pub movement_checks: (bool, bool),
+    /// The `immediate_respawn` game rule, as the players were last told.
+    immediate_respawn: bool,
     /// An integrated server's owner (`MinecraftServer.isSingleplayerOwner`),
     /// whose moves are never checked.
     pub singleplayer_owner: Option<u128>,
@@ -168,6 +194,8 @@ pub struct Hub {
     level_sync: std::collections::HashMap<String, LevelSync>,
     /// Operators and their permission levels (dedicated servers).
     pub ops: std::collections::HashMap<u128, u8>,
+    /// `entity-broadcast-range-percentage` (dedicated servers).
+    pub entity_range_percent: i32,
     chat_type: i32,
     dimension_type: i32,
     clock_ids: Vec<i32>,
@@ -177,6 +205,9 @@ pub struct Hub {
     entities: std::collections::HashMap<String, Entities>,
     /// What one tick of entity tracking sends each guest, kept between ticks.
     entity_out: Vec<Vec<Vec<u8>>>,
+    /// Server mods' commands, a root in the commands report's format, sent
+    /// after vanilla's; the key the game last set them for.
+    mod_commands: (serde_json::Value, Option<u64>),
 }
 
 fn string(s: &str) -> Tag {
@@ -324,6 +355,7 @@ impl Hub {
             guests: Vec::new(),
             sync,
             ticks: 0,
+            immediate_respawn: false,
             movement_checks: (true, true),
             singleplayer_owner: None,
             riding: Default::default(),
@@ -332,6 +364,7 @@ impl Hub {
             ticking: (20.0, false),
             stepping: 0,
             ops: Default::default(),
+            entity_range_percent: 100,
             weather: (false, 0.0, 0.0),
             level_sync: Default::default(),
             chat_type,
@@ -341,6 +374,7 @@ impl Hub {
             entity_types: Default::default(),
             entities: Default::default(),
             entity_out: Vec::new(),
+            mod_commands: (serde_json::Value::Null, None),
             teams: Vec::new(),
         }
     }
@@ -399,6 +433,17 @@ impl Hub {
             g.sender.send(body.clone());
         }
     }
+    /// MinecraftServer.onGameRuleChanged: every player is told when
+    /// `immediate_respawn` changes; a joining player's Login carries it.
+    pub fn set_immediate_respawn(&mut self, on: bool) {
+        if self.immediate_respawn != on {
+            self.immediate_respawn = on;
+            self.broadcast(&C::GameEvent(play::GameEvent {
+                event: game_event::IMMEDIATE_RESPAWN,
+                param: if on { 1.0 } else { 0.0 },
+            }));
+        }
+    }
     /// PlayerList.setViewDistance: every player is told the new radius,
     /// and each one's chunks follow it, up to what they asked for
     /// (ChunkMap.getPlayerViewDistance).
@@ -633,7 +678,7 @@ impl Hub {
             chunk_radius: self.config.view_distance,
             simulation_distance: self.config.simulation_distance,
             reduced_debug_info: false,
-            show_death_screen: true,
+            show_death_screen: !self.immediate_respawn,
             limited_crafting: false,
             spawn: self.spawn_info(mode),
             // MinecraftServer.usesAuthentication, enforceSecureProfile.
@@ -849,13 +894,36 @@ impl Hub {
         }
     }
 
+    /// The key [`Hub::set_mod_commands`] last had: the game compares it
+    /// with its server mods' each tick.
+    pub fn mod_commands_key(&self) -> Option<u64> {
+        self.mod_commands.1
+    }
+    /// Server mods' commands changed: every player gets their tree again.
+    pub fn set_mod_commands(&mut self, key: u64, commands: serde_json::Value) {
+        let resend = self.mod_commands.0 != commands;
+        self.mod_commands = (commands, Some(key));
+        if resend {
+            for i in 0..self.guests.len() {
+                if self.guests[i].placed {
+                    self.send_commands(i);
+                }
+            }
+        }
+    }
+
     /// Commands.sendCommands: the command tree for this player.
     fn send_commands(&self, i: usize) {
         let g = &self.guests[i];
         let packet = match &self.sync.commands {
             Some(tree) => {
                 let dedicated = self.config.dedicated && !self.config.integrated;
-                tree.packet(g.permission, dedicated, &self.sync.builtin)
+                tree.packet_with(
+                    g.permission,
+                    dedicated,
+                    &self.sync.builtin,
+                    &self.mod_commands.0,
+                )
             }
             None => play::Commands {
                 nodes: vec![play::CommandNode {
@@ -1500,6 +1568,49 @@ impl Hub {
 
     // ---- entities ------------------------------------------------------
 
+    /// `LivingEntity.updateSynchronizedMobEffectParticles`: DATA_EFFECT_PARTICLES
+    /// (10) and DATA_EFFECT_AMBIENCE_ID (11) for the visible `effects`, as
+    /// (effect, ambient). The entries are left out when there is nothing to
+    /// show, which is their default.
+    pub fn effect_meta<'a>(
+        &self,
+        effects: impl IntoIterator<Item = (&'a str, bool)>,
+    ) -> Vec<(u8, i32, Value)> {
+        let mut particles = Vec::new();
+        let mut all_ambient = true;
+        for (effect, ambient) in effects {
+            let effect = effect.trim_start_matches("minecraft:");
+            // MobEffect.particleFactory: the omens have their own particles,
+            // the others an entity effect in their colour (faint if ambient).
+            let (name, data) = match effect {
+                "trial_omen" | "raid_omen" => (effect, None),
+                _ => {
+                    let Some(def) = crate::brewing::effect(effect) else {
+                        continue;
+                    };
+                    let alpha = if ambient { 38 } else { 255 };
+                    let argb = (alpha << 24) | def.color as i32;
+                    ("entity_effect", Some(ParticleData::Color(argb)))
+                }
+            };
+            let Some(id) =
+                self.registry_id("minecraft:particle_type", &format!("minecraft:{name}"))
+            else {
+                continue;
+            };
+            particles.push(Particle { id, data });
+            all_ambient &= ambient;
+        }
+        if particles.is_empty() {
+            return Vec::new();
+        }
+        let mut meta = vec![(10, serializer::PARTICLES, Value::Particles(particles))];
+        if all_ambient {
+            meta.push((11, serializer::BOOLEAN, Value::Bool(true)));
+        }
+        meta
+    }
+
     fn player_state(
         &self,
         id: i32,
@@ -1507,21 +1618,29 @@ impl Hub {
         position: [f64; 3],
         rot: (f32, f32, f32),
         on_ground: bool,
-        flags: (bool, bool, bool, bool),
+        flags: (bool, bool, bool),
+        body: BodyFlags,
         living_flags: i8,
         bed: Option<[i32; 3]>,
         skin: u8,
         health: f32,
         equipment: Vec<(u8, Option<horizon_protocol::item::Stack>)>,
         attributes: Vec<play::AttributeSnapshot>,
+        effects: &[EffectInstance],
     ) -> EntityState {
-        let (sneaking, sprinting, gliding, sleeping) = flags;
-        let shared = shared_flags(sneaking, sprinting, gliding);
+        let (sneaking, sprinting, sleeping) = flags;
+        let shared = shared_flags(sneaking, sprinting, &body);
+        // Player.getDesiredPose (and updatePlayerPose's crawl): sleeping,
+        // swimming, gliding, Riptide's spin, crouching.
         let pose = if sleeping {
             2
-        } else if gliding {
+        } else if body.swimming || body.crawling {
+            3
+        } else if body.gliding {
             1
-        } else if sneaking {
+        } else if body.spin_attack {
+            4
+        } else if sneaking || body.crouching {
             5
         } else {
             0
@@ -1547,6 +1666,14 @@ impl Hub {
         if skin != 0 {
             meta.push((16, serializer::BYTE, Value::Byte(skin as i8)));
         }
+        meta.extend(
+            self.effect_meta(
+                effects
+                    .iter()
+                    .filter(|e| e.visible)
+                    .map(|e| (e.id, e.ambient)),
+            ),
+        );
         EntityState {
             id,
             uuid,
@@ -1559,7 +1686,11 @@ impl Hub {
             velocity: [0.0; 3],
             data: 0,
             meta,
-            defaults: Vec::new(),
+            // The effect swirls go back to none.
+            defaults: vec![
+                (10, serializer::PARTICLES, Value::Particles(Vec::new())),
+                (11, serializer::BOOLEAN, Value::Bool(false)),
+            ],
             equipment,
             attributes,
             precise: false,
@@ -1607,13 +1738,15 @@ impl Hub {
                 h.position,
                 (h.yaw, h.pitch, h.head_yaw),
                 h.on_ground,
-                (h.sneaking, h.sprinting, false, h.bed.is_some()),
+                (h.sneaking, h.sprinting, h.bed.is_some()),
+                h.body,
                 h.living_flags,
                 h.bed,
                 0x7F,
                 h.health,
                 equipment,
                 h.attributes.clone(),
+                &[],
             ));
         }
         let placed: Vec<usize> = (0..self.guests.len())
@@ -1639,7 +1772,8 @@ impl Hub {
                     g.position,
                     (g.yaw, g.pitch, g.head_yaw),
                     g.on_ground,
-                    (g.sneaking, g.sprinting, g.fall_flying, g.sleeping),
+                    (g.sneaking, g.sprinting, g.sleeping),
+                    guest_body(g),
                     g.living_flags,
                     g.bed,
                     g.info.model_customisation,
@@ -1649,6 +1783,7 @@ impl Hub {
                         .as_ref()
                         .map(|m| super::attributes::syncable(&m.attributes))
                         .unwrap_or_default(),
+                    &g.effects.list,
                 )
             })
             .collect();
@@ -1678,6 +1813,7 @@ impl Hub {
                 out,
             })
             .collect();
+        level.range_percent = Some(self.entity_range_percent);
         let (types, sync) = (&mut self.entity_types, &self.sync);
         level.tick(&entities, &self.riding, &mut viewers, |kind| {
             entity_type(types, sync, kind)
@@ -1798,7 +1934,7 @@ impl Hub {
         // too, so the sprint a hit stops (Player.causeExtraKnockback) stops
         // on its client.
         let g = &mut self.guests[i];
-        let shared = shared_flags(g.sneaking, g.sprinting, g.fall_flying);
+        let shared = shared_flags(g.sneaking, g.sprinting, &guest_body(g));
         if shared != g.sent_shared {
             g.sent_shared = shared;
             g.send(&C::SetEntityData(play::SetEntityData {
@@ -1947,6 +2083,7 @@ impl Hub {
                 | S::PlayerLoaded(_)
                 | S::ChunkBatchReceived(_)
                 | S::ClientInformation(_)
+                | S::RecipeBookChangeSettings(_)
                 | S::ClientTickEnd(_)
                 | S::KeepAlive(_) => false,
                 S::MovePlayerPos(p) => self.moved_far(i, [p.x, p.y, p.z]),
@@ -2013,6 +2150,15 @@ impl Hub {
                     g.max_unacknowledged = 10;
                 }
                 S::ClientTickEnd(_) => self.guests[i].position_this_tick = false,
+                // ServerGamePacketListenerImpl.handleRecipeBookChangeSettingsPacket.
+                S::RecipeBookChangeSettings(p) => {
+                    if let Some(book) = crate::recipe_book::BookType::ALL.get(p.book_type as usize)
+                    {
+                        let settings = &mut self.guests[i].recipe_book;
+                        settings.open[book.index()] = p.open;
+                        settings.filtering[book.index()] = p.filtering;
+                    }
+                }
                 S::ClientInformation(info) => {
                     let g = &mut self.guests[i];
                     g.view_distance =
@@ -2043,6 +2189,20 @@ impl Hub {
                 S::Chat(c) => self.handle_chat(i, c, events),
                 S::ChatAck(p) => self.chat_ack(i, p.offset, events),
                 S::ChatSessionUpdate(p) => self.chat_session_update(i, p, events),
+                // handlePlayerAction (a dig starting, stopping or finishing) is the
+                // game's, run after this pass. A move queued behind it is checked
+                // against the block the player just broke and falls through, so it
+                // would be sent back; it waits for the next tick, when the block is
+                // gone, as vanilla handles the two packets in order.
+                S::PlayerAction(p) if p.action <= 3 => {
+                    events.push(HostEvent::Packet(conn, Box::new(S::PlayerAction(p))));
+                    if matches!(
+                        self.guests[i].inbox.front(),
+                        Some(S::MovePlayerPos(_) | S::MovePlayerPosRot(_))
+                    ) {
+                        break;
+                    }
+                }
                 other => events.push(HostEvent::Packet(conn, Box::new(other))),
             }
         }
@@ -2134,11 +2294,16 @@ impl Hub {
                 packets = 1;
             }
             // shouldCheckPlayerMovement (never the single-player owner).
-            // The server holds no velocity for a guest (getDeltaMovement),
-            // so nothing is expected.
             if !owner && check && (!g.fall_flying || elytra_check) {
                 let limit = if g.fall_flying { 300.0 } else { 100.0 };
-                if moved > limit * f64::from(packets) {
+                // `movedDist - expectedDist` (getDeltaMovement): the velocity
+                // the server last simulated for the guest is expected
+                // movement, not a violation — a landing glide keeps its speed.
+                let expected = g.motion.as_ref().map_or(0.0, |m| {
+                    let v = m.velocity;
+                    v.x * v.x + v.y * v.y + v.z * v.z
+                });
+                if moved - expected > limit * f64::from(packets) {
                     events.push(HostEvent::Warn(format!(
                         "{} moved too quickly! {},{},{}",
                         g.name,
@@ -2194,18 +2359,8 @@ impl Hub {
         }
         // getBoundingBox: the box of the body's pose (swimming and crawling
         // are 0.6 tall), so a swimmer under a ceiling isn't sent back.
-        let (half, height) = if g.fall_flying {
-            (0.3, 0.6)
-        } else if let Some(m) = &g.motion {
-            (
-                f64::from(m.dimensions.width) / 2.0,
-                f64::from(m.dimensions.height),
-            )
-        } else if g.sneaking {
-            (0.3, 1.5)
-        } else {
-            (0.3, 1.8)
-        };
+        let d = g.dimensions();
+        let (half, height) = (f64::from(d.width) / 2.0, f64::from(d.height));
         let at = |p: [f64; 3]| {
             Aabb::new(
                 Vec3::new(p[0] - half, p[1], p[2] - half),
@@ -2578,16 +2733,44 @@ fn ticking_state(rate: f32, frozen: bool) -> C {
     raw(ids::TICKING_STATE, w.data)
 }
 
-/// Entity.DATA_SHARED_FLAGS_ID of a player: crouching, sprinting, gliding.
-fn shared_flags(sneaking: bool, sprinting: bool, gliding: bool) -> i8 {
+/// What the others see of a guest's body, from its server-side state.
+fn guest_body(g: &Guest) -> BodyFlags {
+    let m = g.motion.as_deref();
+    BodyFlags {
+        gliding: g.fall_flying,
+        swimming: m.is_some_and(|m| m.swimming),
+        crawling: m.is_some_and(|m| m.pose == crate::pose::Pose::Swimming && !m.swimming),
+        crouching: m.is_some_and(|m| m.pose == crate::pose::Pose::Crouching),
+        spin_attack: m.is_some_and(|m| m.auto_spin_attack_ticks > 0),
+        on_fire: m.is_some_and(|m| m.fire_ticks > 0),
+        invisible: g.effects.get("invisibility").is_some(),
+        glowing: g.effects.get("glowing").is_some(),
+    }
+}
+
+/// Entity.DATA_SHARED_FLAGS_ID of a player: on fire 0x01, crouching 0x02,
+/// sprinting 0x08, swimming 0x10, invisible 0x20, glowing 0x40, gliding 0x80.
+fn shared_flags(sneaking: bool, sprinting: bool, body: &BodyFlags) -> i8 {
     let mut shared = 0i8;
+    if body.on_fire {
+        shared |= 0x01;
+    }
     if sneaking {
         shared |= 0x02;
     }
     if sprinting {
         shared |= 0x08;
     }
-    if gliding {
+    if body.swimming {
+        shared |= 0x10;
+    }
+    if body.invisible {
+        shared |= 0x20;
+    }
+    if body.glowing {
+        shared |= 0x40;
+    }
+    if body.gliding {
         shared |= -128;
     }
     shared
diff --git a/crates/horizon-client/src/lan/menu.rs b/crates/horizon-client/src/lan/menu.rs
index 859bafa23..641e45b1b 100644
--- a/crates/horizon-client/src/lan/menu.rs
+++ b/crates/horizon-client/src/lan/menu.rs
@@ -5,7 +5,7 @@
 //! menu are returned for the game to drop.
 use super::guest::Guest;
 use crate::{
-    bundle::{Contents, can_be_in_bundle},
+    bundle::{Contents, can_be_in_bundle, toggle_selected},
     items::{ItemStack, Items},
     world::World,
 };
@@ -514,7 +514,10 @@ fn bundle_click(view: &mut View, i: usize, right: bool, rules: &dyn Rules) -> bo
             }
         }
         (carried, _) => {
+            // toggleSelectedItem(-1), then the click goes on.
             view.guest.carried = carried;
+            toggle_selected(&mut bundle, -1);
+            view.set(i, Some(bundle));
             return false;
         }
     }
diff --git a/crates/horizon-client/src/lan/mod.rs b/crates/horizon-client/src/lan/mod.rs
index 3e9b93cac..34c465ffa 100644
--- a/crates/horizon-client/src/lan/mod.rs
+++ b/crates/horizon-client/src/lan/mod.rs
@@ -142,6 +142,10 @@ pub struct NetConfig {
     /// server.properties `resource-pack`: offered to every player during
     /// configuration (a dedicated server's; MinecraftServer.getServerResourcePack).
     pub resource_pack: Option<crate::server::properties::ResourcePackInfo>,
+    /// MinecraftServer.serverLinks (a dedicated server's `bug-report-link`):
+    /// sent in configuration when non-empty
+    /// (ServerConfigurationPacketListenerImpl.startConfiguration).
+    pub server_links: Vec<horizon_protocol::packets::configuration::ServerLink>,
 }
 impl NetConfig {
     /// MinecraftServer.enforceSecureProfile.
@@ -168,6 +172,7 @@ impl NetConfig {
             online: None,
             log: None,
             resource_pack: None,
+            server_links: Vec::new(),
         }
     }
 }
diff --git a/crates/horizon-client/src/landing.rs b/crates/horizon-client/src/landing.rs
index 6fb1f7580..629d8c042 100644
--- a/crates/horizon-client/src/landing.rs
+++ b/crates/horizon-client/src/landing.rs
@@ -324,10 +324,13 @@ impl BlockLandingWorld for MotionWorld<'_, '_, '_> {
     type DamageSource = LandingDamage;
     type Sound = SceneSound;
     fn is_server_level(&self) -> bool {
-        true
+        // A remote client's world is a client level: it never tramples,
+        // the server's block change and teleport do it (FarmlandBlock.fallOn
+        // and TurtleEggBlock.fallOn check `level instanceof ServerLevel`).
+        !self.player.client_side
     }
     fn is_client_side(&mut self) -> Result<bool> {
-        Ok(false)
+        Ok(self.player.client_side)
     }
     fn random_float(&mut self) -> Result<f32> {
         Ok(self.scene.random.next_float())
diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs
index ebfbdea58..4082c0b0c 100644
--- a/crates/horizon-client/src/lib.rs
+++ b/crates/horizon-client/src/lib.rs
@@ -15,17 +15,16 @@ pub mod auto_jump;
 pub mod banner;
 pub mod beehive;
 pub mod benchmark;
+pub mod bidi;
 pub mod biome;
 pub mod block_entities;
 pub mod block_entity_anim;
 pub mod block_entity_item;
-pub mod block_entity_nbt;
 pub mod block_entity_render;
 pub mod block_transform;
 pub mod blocks;
 pub mod border_render;
 pub mod boss_overlay;
-pub mod bossbar;
 pub mod breaking;
 pub mod brewing;
 pub mod bundle;
@@ -38,10 +37,8 @@ pub mod clipboard;
 pub mod clock;
 pub mod clouds;
 pub mod collisions;
-pub mod command;
 pub mod command_block;
 pub mod command_storage;
-pub mod component;
 pub mod confirm_screen;
 pub mod container_screen;
 pub mod containers;
@@ -71,7 +68,6 @@ pub mod extras;
 pub mod extras_hud;
 pub mod falling_block;
 pub mod fast_hash;
-pub mod fastutil_order;
 pub mod fire_render;
 pub mod first_person;
 pub mod flatgen;
@@ -79,8 +75,8 @@ pub mod fog;
 pub mod font;
 pub mod friends_screen;
 pub mod game_mode_switcher;
+pub mod game_rules_screen;
 pub mod gamepad;
-pub mod gamerules;
 pub mod gfx;
 pub mod gizmos;
 pub mod gossip;
@@ -109,7 +105,6 @@ pub mod keybinds;
 pub mod keymapping;
 pub mod lan;
 pub mod landing;
-pub mod lang;
 pub mod level_loading;
 pub mod light;
 pub mod locator_bar;
@@ -131,7 +126,6 @@ pub mod mouse;
 pub mod moved_extras;
 pub mod multiplayer;
 pub mod music;
-pub mod nbt_path;
 pub mod net;
 pub mod nether_portal;
 pub mod offline_name;
@@ -160,7 +154,6 @@ pub mod recipe_book;
 pub mod recipe_book_screen;
 pub mod reconnect;
 pub mod save;
-pub mod scoreboard;
 pub mod scoreboard_cmd;
 pub mod screen_draw;
 pub mod screen_effects;
@@ -173,7 +166,6 @@ pub mod shader_pack_list;
 pub mod shadows;
 pub mod signs;
 pub mod skins;
-pub mod snbt;
 pub mod sound_engine;
 pub mod sound_events;
 pub mod spans;
@@ -186,7 +178,6 @@ pub mod structure_blocks;
 pub mod tab_list;
 pub mod telemetry;
 pub mod testgen;
-pub mod text;
 pub mod text_display;
 pub mod tick_chunk_membership;
 pub mod ticket_levels;
@@ -206,4 +197,15 @@ pub mod world;
 pub mod world_spawn;
 pub mod worldborder;
 pub mod zip;
-pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
+pub use horizon_client_core::Result;
+pub use horizon_client_core::block_entity_nbt;
+pub use horizon_client_core::bossbar;
+pub use horizon_client_core::component;
+pub use horizon_client_core::fastutil_order;
+pub use horizon_client_core::gamerules;
+pub use horizon_client_core::lang;
+pub use horizon_client_core::nbt_path;
+pub use horizon_client_core::scoreboard;
+pub use horizon_client_core::snbt;
+pub use horizon_client_core::text;
+pub use horizon_command as command;
diff --git a/crates/horizon-client/src/light.rs b/crates/horizon-client/src/light.rs
index 6cb4b65b1..c8313c3d7 100644
--- a/crates/horizon-client/src/light.rs
+++ b/crates/horizon-client/src/light.rs
@@ -17,7 +17,7 @@
 use crate::fast_hash::FxHashMap;
 use crate::{
     blocks::BlockFacts,
-    chunk::{Chunk, HEIGHT, Light, MIN_Y, SECTIONS, index},
+    chunk::{Chunk, HEIGHT, Light, MIN_Y, SECTIONS, Section, index},
 };
 use horizon_core::geometry::{Direction, ShapeOp, VoxelShape};
 use horizon_world::registry::{BlockRegistry, BlockStateId};
@@ -565,43 +565,130 @@ pub fn update_light_layers<L: AsRef<[u8]>>(
 
 /// Resident chunks the incremental relighter reads and writes.
 pub trait LightWorld {
-    fn state(&self, x: i32, y: i32, z: i32) -> Option<u32>;
-    /// Packed light (sky << 4 | block), None outside loaded chunks.
-    fn light(&self, x: i32, y: i32, z: i32) -> Option<u8>;
-    fn set_light(&mut self, x: i32, y: i32, z: i32, packed: u8);
+    /// Section `s` of chunk (cx, cz), None unless the chunk is loaded and lit.
+    fn section(&self, cx: i32, s: usize, cz: i32) -> Option<&Arc<Section>>;
+    /// Replace the light of a section `section` returned.
+    fn set_section_light(&mut self, cx: i32, s: usize, cz: i32, light: Light);
 }
 impl<S: std::hash::BuildHasher> LightWorld for HashMap<(i32, i32), Arc<Chunk>, S> {
-    fn state(&self, x: i32, y: i32, z: i32) -> Option<u32> {
+    fn section(&self, cx: i32, s: usize, cz: i32) -> Option<&Arc<Section>> {
+        self.get(&(cx, cz))
+            .filter(|c| c.lit)
+            .map(|c| &c.sections[s])
+    }
+    fn set_section_light(&mut self, cx: i32, s: usize, cz: i32, light: Light) {
+        if let Some(chunk) = self.get_mut(&(cx, cz)) {
+            Arc::make_mut(&mut Arc::make_mut(chunk).sections[s]).light = light;
+        }
+    }
+}
+/// The sections one relight touches, held for the whole flood fill so each
+/// cell access is an array index instead of a chunk lookup. Light a section
+/// gets written is copied out on the first write and stored back by `finish`.
+struct Region<'w> {
+    world: &'w mut dyn LightWorld,
+    slots: Vec<Slot>,
+    /// Section key (cx, s, cz) to slot, `NONE` where the chunk isn't lit.
+    index: FxHashMap<Pos, u32>,
+    last: (Pos, u32),
+}
+struct Slot {
+    key: Pos,
+    /// The world's section; its light is the value before this relight.
+    section: Arc<Section>,
+    light: Option<Box<[u8; 4096]>>,
+}
+const NONE: u32 = u32::MAX;
+impl<'w> Region<'w> {
+    fn new(world: &'w mut dyn LightWorld) -> Self {
+        Self {
+            world,
+            slots: Vec::new(),
+            index: FxHashMap::default(),
+            last: ((i32::MIN, 0, 0), NONE),
+        }
+    }
+    #[inline]
+    fn slot(&mut self, x: i32, y: i32, z: i32) -> Option<usize> {
         if !(MIN_Y..MIN_Y + HEIGHT).contains(&y) {
             return None;
         }
-        self.get(&(x >> 4, z >> 4))
-            .filter(|c| c.lit)
-            .map(|c| c.get(x & 15, y, z & 15))
-    }
-    fn light(&self, x: i32, y: i32, z: i32) -> Option<u8> {
-        if !(MIN_Y..MIN_Y + HEIGHT).contains(&y) {
-            return None;
+        let key = (x >> 4, (y - MIN_Y) >> 4, z >> 4);
+        if self.last.0 != key {
+            self.last = (key, self.load(key));
         }
-        self.get(&(x >> 4, z >> 4))
-            .filter(|c| c.lit)
-            .map(|c| c.light(x & 15, y, z & 15))
+        (self.last.1 != NONE).then_some(self.last.1 as usize)
     }
-    fn set_light(&mut self, x: i32, y: i32, z: i32, packed: u8) {
-        let Some(chunk) = self.get_mut(&(x >> 4, z >> 4)) else {
+    fn load(&mut self, key: Pos) -> u32 {
+        if let Some(&slot) = self.index.get(&key) {
+            return slot;
+        }
+        let slot = match self.world.section(key.0, key.1 as usize, key.2) {
+            Some(section) => {
+                self.slots.push(Slot {
+                    key,
+                    section: section.clone(),
+                    light: None,
+                });
+                (self.slots.len() - 1) as u32
+            }
+            None => NONE,
+        };
+        self.index.insert(key, slot);
+        slot
+    }
+    fn state(&mut self, x: i32, y: i32, z: i32) -> Option<u32> {
+        let slot = self.slot(x, y, z)?;
+        Some(self.slots[slot].section.get(index(x, y, z)))
+    }
+    /// Packed light (sky << 4 | block), None outside loaded, lit chunks.
+    fn light(&mut self, x: i32, y: i32, z: i32) -> Option<u8> {
+        let slot = self.slot(x, y, z)?;
+        let slot = &self.slots[slot];
+        let i = index(x, y, z);
+        Some(match &slot.light {
+            Some(light) => light[i],
+            None => slot.section.light(i),
+        })
+    }
+    /// State and packed light of a cell, with a single section lookup.
+    fn cell(&mut self, x: i32, y: i32, z: i32) -> Option<(u32, u8)> {
+        let slot = self.slot(x, y, z)?;
+        let slot = &self.slots[slot];
+        let i = index(x, y, z);
+        let light = match &slot.light {
+            Some(light) => light[i],
+            None => slot.section.light(i),
+        };
+        Some((slot.section.get(i), light))
+    }
+    /// Rewrite a cell's packed light; nothing outside loaded, lit chunks.
+    fn update_light(&mut self, x: i32, y: i32, z: i32, f: impl FnOnce(u8) -> u8) {
+        let Some(slot) = self.slot(x, y, z) else {
             return;
         };
-        let s = ((y - MIN_Y) >> 4) as usize;
+        let slot = &mut self.slots[slot];
+        let light = slot.light.get_or_insert_with(|| match &slot.section.light {
+            Light::Uniform(v) => Box::new([*v; 4096]),
+            Light::Full(a) => a.clone(),
+        });
         let i = index(x, y, z);
-        if chunk.sections[s].light(i) == packed {
-            return;
-        }
-        let section = Arc::make_mut(&mut Arc::make_mut(chunk).sections[s]);
-        if let Light::Uniform(v) = section.light {
-            section.light = Light::Full(Box::new([v; 4096]));
-        }
-        if let Light::Full(a) = &mut section.light {
-            a[i] = packed;
+        light[i] = f(light[i]);
+    }
+    /// Store back the light of every section whose values changed.
+    fn finish(self) {
+        for slot in self.slots {
+            let Some(light) = slot.light else {
+                continue;
+            };
+            if (0..4096).all(|i| slot.section.light(i) == light[i]) {
+                continue;
+            }
+            // Drop the clone first so the world's section isn't copied.
+            drop(slot.section);
+            let (cx, s, cz) = slot.key;
+            self.world
+                .set_section_light(cx, s as usize, cz, Light::Full(light));
         }
     }
 }
@@ -690,25 +777,23 @@ impl LightChanges {
         }
     }
 }
-fn level(world: &impl LightWorld, sky: bool, p: Pos) -> Option<u8> {
+fn level(world: &mut Region, sky: bool, p: Pos) -> Option<u8> {
     world
         .light(p.0, p.1, p.2)
         .map(|v| if sky { v >> 4 } else { v & 15 })
 }
-fn set_level(world: &mut impl LightWorld, sky: bool, p: Pos, value: u8) {
-    let Some(old) = world.light(p.0, p.1, p.2) else {
-        return;
-    };
-    let packed = if sky {
-        (old & 0x0F) | value << 4
-    } else {
-        (old & 0xF0) | value
-    };
-    world.set_light(p.0, p.1, p.2, packed);
+fn set_level(world: &mut Region, sky: bool, p: Pos, value: u8) {
+    world.update_light(p.0, p.1, p.2, |old| {
+        if sky {
+            (old & 0x0F) | value << 4
+        } else {
+            (old & 0xF0) | value
+        }
+    });
 }
 /// `ChunkSkyLightSources`: the Y of the upper block of the highest occluded
 /// edge in the column (every block at or above it is a sky source).
-pub fn lowest_sky_source(world: &impl LightWorld, tables: &LightTables, x: i32, z: i32) -> i32 {
+fn lowest_sky_source(world: &mut Region, tables: &LightTables, x: i32, z: i32) -> i32 {
     let mut y = MIN_Y + HEIGHT - 1;
     let Some(mut top) = world.state(x, y, z) else {
         return MIN_Y;
@@ -739,34 +824,52 @@ pub fn relight(
     force: bool,
     changed: &mut LightChanges,
 ) {
-    relight_layer(world, tables, false, positions.to_vec(), force, changed);
+    let mut region = Region::new(world);
+    relight_region(&mut region, tables, sky_light, positions, force, changed);
+    region.finish();
+}
+fn relight_region(
+    world: &mut Region,
+    tables: &LightTables,
+    sky_light: bool,
+    positions: &[Pos],
+    force: bool,
+    changed: &mut LightChanges,
+) {
+    crate::spans::time("lt_block", || {
+        relight_layer(world, tables, false, positions.to_vec(), force, changed)
+    });
     if sky_light {
         let mut seeds = positions.to_vec();
-        let mut columns: HashMap<(i32, i32), i32> = HashMap::new();
-        for &(x, _, z) in positions {
-            if columns.contains_key(&(x, z)) {
-                continue;
-            }
-            let source = lowest_sky_source(world, tables, x, z);
-            columns.insert((x, z), source);
-            // Cells whose source status changed: non-15 at or above the new
-            // lowest source, and old 15s (sources) below it.
-            for y in source..MIN_Y + HEIGHT {
-                if level(world, true, (x, y, z)).is_some_and(|l| l != 15) {
+        let mut columns: FxHashMap<(i32, i32), i32> = FxHashMap::default();
+        crate::spans::time("lt_columns", || {
+            for &(x, _, z) in positions {
+                if columns.contains_key(&(x, z)) {
+                    continue;
+                }
+                let source = lowest_sky_source(world, tables, x, z);
+                columns.insert((x, z), source);
+                // Cells whose source status changed: non-15 at or above the new
+                // lowest source, and old 15s (sources) below it.
+                for y in source..MIN_Y + HEIGHT {
+                    if level(world, true, (x, y, z)).is_some_and(|l| l != 15) {
+                        seeds.push((x, y, z));
+                    }
+                }
+                let mut y = source - 1;
+                while y >= MIN_Y && level(world, true, (x, y, z)) == Some(15) {
                     seeds.push((x, y, z));
+                    y -= 1;
                 }
             }
-            let mut y = source - 1;
-            while y >= MIN_Y && level(world, true, (x, y, z)) == Some(15) {
-                seeds.push((x, y, z));
-                y -= 1;
-            }
-        }
-        relight_layer(world, tables, true, seeds, force, changed);
+        });
+        crate::spans::time("lt_sky", || {
+            relight_layer(world, tables, true, seeds, force, changed)
+        });
     }
 }
 fn relight_layer(
-    world: &mut impl LightWorld,
+    world: &mut Region,
     tables: &LightTables,
     sky: bool,
     seeds: Vec<Pos>,
@@ -809,42 +912,40 @@ fn relight_layer(
         }
     }
     // Sources inside the cleared area light up again.
-    let mut sources: HashMap<(i32, i32), i32> = HashMap::new();
-    for p in cleared {
-        let seed = if sky {
-            let lowest = *sources
-                .entry((p.0, p.2))
-                .or_insert_with(|| lowest_sky_source(world, tables, p.0, p.2));
-            if p.1 >= lowest { 15 } else { 0 }
-        } else {
-            world
-                .state(p.0, p.1, p.2)
-                .map_or(0, |s| tables.cells[s as usize].emission)
-        };
-        if seed > level(world, sky, p).unwrap_or(15) {
-            set_level(world, sky, p, seed);
-            changed.push(p);
-            increase.push_back(p);
+    let mut sources: FxHashMap<(i32, i32), i32> = FxHashMap::default();
+    crate::spans::time("lt_sources", || {
+        for p in cleared {
+            let seed = if sky {
+                let lowest = *sources
+                    .entry((p.0, p.2))
+                    .or_insert_with(|| lowest_sky_source(world, tables, p.0, p.2));
+                if p.1 >= lowest { 15 } else { 0 }
+            } else {
+                world
+                    .state(p.0, p.1, p.2)
+                    .map_or(0, |s| tables.cells[s as usize].emission)
+            };
+            if seed > level(world, sky, p).unwrap_or(15) {
+                set_level(world, sky, p, seed);
+                changed.push(p);
+                increase.push_back(p);
+            }
         }
-    }
+    });
     while let Some(p) = increase.pop_front() {
-        let Some(l) = level(world, sky, p) else {
+        let Some((from, packed)) = world.cell(p.0, p.1, p.2) else {
             continue;
         };
+        let l = if sky { packed >> 4 } else { packed & 15 };
         if l <= 1 {
             continue;
         }
-        let Some(from) = world.state(p.0, p.1, p.2) else {
-            continue;
-        };
         for (d, (ox, oy, oz)) in OFFSETS.iter().enumerate() {
             let q = (p.0 + ox, p.1 + oy, p.2 + oz);
-            let Some(to) = world.state(q.0, q.1, q.2) else {
-                continue;
-            };
-            let Some(ql) = level(world, sky, q) else {
+            let Some((to, packed)) = world.cell(q.0, q.1, q.2) else {
                 continue;
             };
+            let ql = if sky { packed >> 4 } else { packed & 15 };
             let next = l.saturating_sub(tables.cells[to as usize].dampening.max(1));
             if next > ql && !tables.blocked(from as usize, to as usize, d) {
                 set_level(world, sky, q, next);
@@ -915,10 +1016,10 @@ mod tests {
         lit.into_iter().collect()
     }
     fn sky(world: &HashMap<(i32, i32), Arc<Chunk>>, x: i32, y: i32, z: i32) -> u8 {
-        world.light(x, y, z).unwrap() >> 4
+        world[&(x >> 4, z >> 4)].light(x & 15, y, z & 15) >> 4
     }
     fn block(world: &HashMap<(i32, i32), Arc<Chunk>>, x: i32, y: i32, z: i32) -> u8 {
-        world.light(x, y, z).unwrap() & 15
+        world[&(x >> 4, z >> 4)].light(x & 15, y, z & 15) & 15
     }
 
     #[test]
@@ -954,6 +1055,108 @@ mod tests {
         assert_eq!(sky(&w, 8, 2, 8), 0, "the full bottom face stops sky light");
     }
     #[test]
+    fn relight_keeps_unchanged_and_unlit_sections() {
+        let mut w = world(|_| {});
+        Arc::make_mut(w.get_mut(&(1, 0)).unwrap()).lit = false;
+        let before = w.clone();
+        let same = |w: &HashMap<(i32, i32), Arc<Chunk>>, key| {
+            w[&key]
+                .sections
+                .iter()
+                .zip(&before[&key].sections)
+                .all(|(a, b)| Arc::ptr_eq(a, b))
+        };
+        // Cleared and lit back to the same values: nothing is stored.
+        relight(
+            &mut w,
+            &tables(),
+            true,
+            &[(8, 5, 8)],
+            false,
+            &mut LightChanges::default(),
+        );
+        assert!(w.keys().all(|&key| same(&w, key)));
+        // Light reaching an unlit chunk isn't written into it.
+        Arc::make_mut(w.get_mut(&(0, 0)).unwrap()).set(15, 0, 8, TORCH);
+        relight(
+            &mut w,
+            &tables(),
+            true,
+            &[(15, 0, 8)],
+            false,
+            &mut LightChanges::default(),
+        );
+        assert!(same(&w, (1, 0)));
+        assert_eq!(block(&w, 14, 0, 8), 13);
+    }
+    #[test]
+    fn random_border_relights_match_full_relight() {
+        // Edits around every border of chunk (0, 0), at the top and bottom of
+        // the world, in batches; a held clone of the chunk must not change.
+        let mut w = world(|_| {});
+        let held = w[&(0, 0)].clone();
+        let mut rng = 0x9e37_79b9_u32;
+        let mut next = |n: usize| {
+            rng ^= rng << 13;
+            rng ^= rng >> 17;
+            rng ^= rng << 5;
+            rng as usize % n
+        };
+        let xz = [-2, -1, 0, 1, 7, 14, 15, 16, 17];
+        let ys = [
+            MIN_Y,
+            MIN_Y + 1,
+            -2,
+            -1,
+            0,
+            1,
+            15,
+            16,
+            MIN_Y + HEIGHT - 2,
+            MIN_Y + HEIGHT - 1,
+        ];
+        for _ in 0..60 {
+            let positions: Vec<Pos> = (0..1 + next(6))
+                .map(|_| (xz[next(xz.len())], ys[next(ys.len())], xz[next(xz.len())]))
+                .collect();
+            for &(x, y, z) in &positions {
+                let state = [TORCH, SLAB, AIR, STONE][next(4)];
+                Arc::make_mut(w.get_mut(&(x >> 4, z >> 4)).unwrap()).set(x & 15, y, z & 15, state);
+            }
+            relight(
+                &mut w,
+                &tables(),
+                true,
+                &positions,
+                false,
+                &mut LightChanges::default(),
+            );
+        }
+        // Every chunk, the outer ring lit as `world` lit it (no neighbours
+        // past the 3x3).
+        for (&(cx, cz), chunk) in &w {
+            let region: [[Option<&Chunk>; 3]; 3] = std::array::from_fn(|dz| {
+                std::array::from_fn(|dx| {
+                    w.get(&(cx + dx as i32 - 1, cz + dz as i32 - 1))
+                        .map(|c| &**c)
+                })
+            });
+            for (si, s) in light_chunk(&region, &tables(), true).iter().enumerate() {
+                for i in 0..4096 {
+                    assert_eq!(
+                        s.get(i),
+                        chunk.sections[si].light(i),
+                        "chunk {cx},{cz} section {si} index {i}"
+                    );
+                }
+            }
+        }
+        let fresh = world(|_| {});
+        for (a, b) in held.sections.iter().zip(&fresh[&(0, 0)].sections) {
+            assert!((0..4096).all(|i| a.light(i) == b.light(i)));
+        }
+    }
+    #[test]
     fn incremental_relight_matches_full_relight() {
         let mut w = world(|c| {
             c.set(8, 0, 8, TORCH);
@@ -1319,4 +1522,37 @@ mod tests {
             "fixture heap payload {payload} bytes; old worker clones it plus 24 section Arcs; old application clones current payload and 98304 returned light bytes. New worker clones zero section payload; new application clones current payload only when shared."
         );
     }
+    /// Relight cost for torches placed and removed near chunk borders with
+    /// slabs flickering around them (fluids next to lava, in the game).
+    /// `cargo test --profile fast -p horizon-client relight_bench -- --ignored --nocapture`
+    #[test]
+    #[ignore]
+    fn relight_bench() {
+        let mut w: FxHashMap<_, _> = world(|_| {}).into_iter().collect();
+        let t = tables();
+        let mut rng = 0x2545_f491_u32;
+        let mut next = |n: i32| {
+            rng ^= rng << 13;
+            rng ^= rng >> 17;
+            rng ^= rng << 5;
+            (rng % n as u32) as i32
+        };
+        let start = std::time::Instant::now();
+        let mut changed = LightChanges::default();
+        for round in 0..400 {
+            let state = [TORCH, SLAB, AIR][round % 3];
+            let positions: Vec<Pos> = (0..32)
+                .map(|_| (next(32) - 8, next(12), next(32) - 8))
+                .collect();
+            for &(x, y, z) in &positions {
+                Arc::make_mut(w.get_mut(&(x >> 4, z >> 4)).unwrap()).set(x & 15, y, z & 15, state);
+            }
+            relight(&mut w, &t, true, &positions, false, &mut changed);
+        }
+        println!(
+            "relight_bench: {:?}, {} sections",
+            start.elapsed(),
+            changed.sections().count()
+        );
+    }
 }
diff --git a/crates/horizon-client/src/menu.rs b/crates/horizon-client/src/menu.rs
index 3b2b8fd31..1aeeec1e1 100644
--- a/crates/horizon-client/src/menu.rs
+++ b/crates/horizon-client/src/menu.rs
@@ -288,6 +288,9 @@ pub struct Menu {
     pub player_sounds: Vec<&'static str>,
     /// Recipes whose result was taken (`awardUsedRecipes`), for the caller.
     pub crafted: Vec<String>,
+    /// Potions taken from a brewing stand's bottle slots
+    /// (`PotionSlot.onTake`), for the caller.
+    pub brewed: Vec<ItemStack>,
     /// `LivingEntity.onEquipItem` calls that change the item: the
     /// `EquipmentSlot` name and the new stack, in order, for the caller.
     pub equipped: Vec<(&'static str, Option<ItemStack>)>,
@@ -683,6 +686,7 @@ impl Menu {
             sounds: Vec::new(),
             player_sounds: Vec::new(),
             crafted: Vec::new(),
+            brewed: Vec::new(),
             equipped: Vec::new(),
             merchant: None,
             stone: Stonecutter::default(),
@@ -1504,7 +1508,17 @@ impl Menu {
     }
 
     /// `ResultSlot.onTake` and the other `Slot.onTake` overrides.
-    fn on_take(&mut self, env: &Env, s: usize) {
+    fn on_take(&mut self, env: &Env, s: usize, taken: &ItemStack) {
+        if self.slots[s].role == Role::Potion {
+            // BrewingStandMenu.PotionSlot.onTake: a stack with potion contents.
+            if matches!(
+                &*taken.item,
+                "minecraft:potion" | "minecraft:splash_potion" | "minecraft:lingering_potion"
+            ) {
+                self.brewed.push(taken.clone());
+            }
+            return;
+        }
         if self.slots[s].role == Role::MerchantResult {
             self.merchant_take(env);
             return;
@@ -1671,7 +1685,7 @@ impl Menu {
         max_amount: u32,
     ) -> Option<ItemStack> {
         let mut result = self.try_remove(env, s, amount, max_amount)?;
-        self.on_take(env, s);
+        self.on_take(env, s, &result);
         if self.slots[s].role == Role::CartoResult {
             Self::map_crafted(env, &mut result);
         }
@@ -2346,7 +2360,7 @@ impl Menu {
             return None;
         }
         if after_take || matches!(self.kind, Kind::Inventory | Kind::Crafting) {
-            self.on_take(env, index);
+            self.on_take(env, index, &clicked);
         }
         // What the result slot's move left over is dropped.
         if (index == 0 && matches!(self.kind, Kind::Inventory | Kind::Crafting))
@@ -2594,7 +2608,7 @@ impl Menu {
                     };
                     if let Some(mut taken) = self.try_remove(env, s, amount, u32::MAX) {
                         self.carried = Some(taken.clone());
-                        self.on_take(env, s);
+                        self.on_take(env, s, &taken);
                         if self.slots[s].role == Role::CartoResult {
                             // onTake's onCraftedBy edits the carried stack.
                             Self::map_crafted(env, &mut taken);
@@ -2628,7 +2642,7 @@ impl Menu {
                             if let Some(c) = self.carried.as_mut() {
                                 c.count += taken.count;
                             }
-                            self.on_take(env, s);
+                            self.on_take(env, s, &taken);
                             if self.slots[s].role == Role::CartoResult {
                                 // onCraftedBy edits the taken stack, not the carried one.
                                 Self::map_crafted(env, &mut taken);
@@ -2656,7 +2670,7 @@ impl Menu {
                 if self.may_pickup(env, target) {
                     self.containers[PLAYER][inv_slot] = Some(taken.clone());
                     self.set_by_player(env, target, None);
-                    self.on_take(env, target);
+                    self.on_take(env, target, &taken);
                     if self.slots[target].role == Role::CartoResult
                         && let Some(stack) = self.containers[PLAYER][inv_slot].as_mut()
                     {
@@ -2684,14 +2698,14 @@ impl Menu {
                         let part = split(&mut source, max);
                         self.containers[PLAYER][inv_slot] = Some(source);
                         self.set_by_player(env, target, Some(part));
-                        self.on_take(env, target);
+                        self.on_take(env, target, &taken);
                         if !self.inventory_add(env, &mut taken) {
                             self.drop_stack(&taken);
                         }
                     } else {
-                        self.containers[PLAYER][inv_slot] = Some(taken);
+                        self.containers[PLAYER][inv_slot] = Some(taken.clone());
                         self.set_by_player(env, target, Some(source));
-                        self.on_take(env, target);
+                        self.on_take(env, target, &taken);
                     }
                 }
             }
@@ -3211,4 +3225,64 @@ pub(crate) mod tests {
             assert_eq!(menu.slot(0), stack("dirt", 1).as_ref());
         });
     }
+
+    /// #1737: a Shift+Right-Click quick move in a chest (a double chest's
+    /// 54 slots) moves the stack and leaves the menu's state clean, so the
+    /// next quick move still moves its stack and the inventory still
+    /// answers.
+    #[test]
+    fn a_chest_quick_move_keeps_the_next_one_working() {
+        with_menu(Kind::Chest(6), |env, menu| {
+            menu.creative = false;
+            // The hotbar holds two stacks; the chest is empty.
+            menu.set_slot(env, 81, stack("cobblestone", 64));
+            menu.set_slot(env, 82, stack("dirt", 32));
+            // Shift+Right-Click on the hotbar: the stack goes into the chest.
+            menu.click(env, 81, 1, Input::QuickMove).unwrap();
+            assert_eq!(menu.slot(81), None);
+            assert_eq!(menu.slot(0).map(|s| s.count), Some(64));
+            // Nothing is left on the cursor and no quick craft is running.
+            assert_eq!(menu.carried, None);
+            assert_eq!(menu.quick_status, 0);
+            // The next quick move still works.
+            menu.click(env, 82, 1, Input::QuickMove).unwrap();
+            assert_eq!(menu.slot(82), None);
+            assert_eq!(menu.slot(1).map(|s| s.count), Some(32));
+            assert_eq!(menu.carried, None);
+            assert_eq!(menu.quick_status, 0);
+        });
+    }
+
+    /// #1832: a potion taken from the creative inventory and put in the
+    /// hotbar keeps its `PotionContents` (the brew), as vanilla's
+    /// `PotionContents.createItemStack` builds it: the item tab's stack is
+    /// the real one, and the hotbar slot holds it as it is.
+    #[test]
+    fn a_creative_potion_keeps_its_contents_in_the_hotbar() {
+        let snbt = r#"{components:{"minecraft:potion_contents":{potion:"minecraft:swiftness"}},count:1,id:"minecraft:potion"}"#;
+        let potion = crate::item_data::parse_stack(snbt).unwrap().unwrap();
+        assert_eq!(potion.potion(), Some("minecraft:swiftness"));
+        // The creative screen hands the stack over...
+        let mut carried = None;
+        crate::creative::click_display(
+            &mut carried,
+            Some(&potion),
+            |_: &ItemStack| 1,
+            0,
+            Input::Pickup,
+        );
+        assert_eq!(
+            carried.as_ref().and_then(|s| s.potion()),
+            Some("minecraft:swiftness")
+        );
+        // ... and the hotbar slot keeps it: it is not the uncraftable
+        // potion, which is a `minecraft:potion` with no contents at all.
+        with_menu(Kind::ItemPicker, |env, menu| {
+            menu.carried = carried;
+            menu.click(env, 45, 0, Input::Pickup).unwrap();
+            let in_hand = menu.slot(45).expect("the hotbar slot");
+            assert_eq!(in_hand.potion(), Some("minecraft:swiftness"));
+            assert_eq!(&*in_hand.item, "minecraft:potion");
+        });
+    }
 }
diff --git a/crates/horizon-client/src/menu/bundle.rs b/crates/horizon-client/src/menu/bundle.rs
index fba4a488e..78a52655a 100644
--- a/crates/horizon-client/src/menu/bundle.rs
+++ b/crates/horizon-client/src/menu/bundle.rs
@@ -1,7 +1,7 @@
 //! `BundleItem`'s click overrides in a PICKUP click
 //! (`tryItemClickBehaviourOverride`).
 use super::{Env, Menu, tidy};
-use crate::bundle::{Contents, INSERT, INSERT_FAIL, REMOVE_ONE, can_be_in_bundle};
+use crate::bundle::{Contents, INSERT, INSERT_FAIL, REMOVE_ONE, can_be_in_bundle, toggle_selected};
 
 impl Menu {
     /// The carried stack's `overrideStackedOnOther`, then the clicked
@@ -88,8 +88,11 @@ impl Menu {
                 }
             }
             (carried, _) => {
-                // toggleSelectedItem(-1): Horizon keeps no selected item.
+                // toggleSelectedItem(-1), then the click goes on.
                 self.carried = carried;
+                toggle_selected(&mut bundle, -1);
+                let slot = self.slots[s];
+                self.containers[slot.container][slot.index] = Some(bundle);
                 return false;
             }
         }
diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs
index 48d2f08bd..7594e7e31 100644
--- a/crates/horizon-client/src/mesher.rs
+++ b/crates/horizon-client/src/mesher.rs
@@ -38,6 +38,8 @@ pub struct Vertex {
     pub light: u32,
     /// RGBA8_SNORM face normal; w = -127 for two-sided lighting, 0 to keep baked/unlit colour.
     pub normal: [i8; 4],
+    /// The `GLINT_TEXTURING` atlas UV for a foil item quad; zero elsewhere.
+    pub glint_uv: [f32; 2],
 }
 /// A section vertex: vanilla's `DefaultVertexFormat.BLOCK` (position, colour,
 /// UV0, UV2) with the sprite's array layer beside the light, in 24 bytes
diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs
index 00c21633e..f4ab3f834 100644
--- a/crates/horizon-client/src/mobs.rs
+++ b/crates/horizon-client/src/mobs.rs
@@ -25,6 +25,7 @@ pub mod creaking;
 pub mod creaking_heart;
 pub mod cube;
 pub mod data;
+pub mod doors;
 pub mod drops;
 pub mod enderman;
 pub mod equine;
@@ -49,6 +50,7 @@ pub mod nether;
 pub mod path;
 pub mod phantom;
 pub mod piglin;
+pub mod polar_bear;
 pub mod rabbit;
 pub mod raider;
 pub mod ravager;
@@ -64,10 +66,12 @@ pub mod spawning;
 pub mod species;
 pub mod strider;
 pub mod sulfur_cube;
+pub mod sync;
 pub mod tame;
 pub mod trader;
 pub mod transport_items;
 pub mod trial_spawner;
+pub mod turtle;
 pub mod undead;
 pub mod vex;
 pub mod villager;
@@ -515,6 +519,8 @@ pub enum DamageKind {
     InFire,
     Lava,
     Drown,
+    /// `dry_out`: an axolotl out of water for too long.
+    DryOut,
     Magic,
     Sting,
     Cactus,
@@ -522,6 +528,8 @@ pub enum DamageKind {
     InWall,
     Thorns,
     SonicBoom,
+    /// `freeze`: a fully frozen mob in powder snow.
+    Freeze,
     /// `fell_out_of_world`: below the world's floor.
     OutOfWorld,
 }
@@ -573,7 +581,11 @@ impl Damage {
     pub fn causes_panic(&self) -> bool {
         !matches!(
             self.kind,
-            DamageKind::Fall | DamageKind::Drown | DamageKind::Generic | DamageKind::InWall
+            DamageKind::Fall
+                | DamageKind::Drown
+                | DamageKind::DryOut
+                | DamageKind::Generic
+                | DamageKind::InWall
         )
     }
     /// DamageTypeTags.BYPASSES_ARMOR
@@ -587,6 +599,7 @@ impl Damage {
                 | DamageKind::InWall
                 | DamageKind::Generic
                 | DamageKind::SonicBoom
+                | DamageKind::Freeze
                 | DamageKind::OutOfWorld
         )
     }
@@ -606,10 +619,12 @@ impl Damage {
                 | DamageKind::InFire
                 | DamageKind::Lava
                 | DamageKind::Drown
+                | DamageKind::DryOut
                 | DamageKind::Magic
                 | DamageKind::Cactus
                 | DamageKind::Generic
                 | DamageKind::InWall
+                | DamageKind::Freeze
                 | DamageKind::OutOfWorld
         )
     }
@@ -636,6 +651,11 @@ pub struct Attrs {
 pub struct Extra {
     /// Players: crouching and riding (HumanoidModel's poses).
     pub crouching: bool,
+    /// A player's or mannequin's synced pose (`Entity.DATA_POSE`), which
+    /// sets its box (`Avatar.POSES`).
+    pub avatar_pose: crate::pose::Pose,
+    /// Players: sprinting (`Entity.DATA_SHARED_FLAGS_ID`), for the dust they raise.
+    pub sprinting: bool,
     pub passenger: bool,
     /// AgeableMob.age: negative while a baby (a tadpole counts up to 24000).
     pub age: i32,
@@ -665,6 +685,8 @@ pub struct Extra {
     pub chested: bool,
     /// The chest contents of a donkey or mule (15 slots).
     pub items: Vec<Option<crate::items::ItemStack>>,
+    /// `Piglin.inventory` (`SimpleContainer(8)`): what it picked up and kept.
+    pub inventory: Vec<crate::items::ItemStack>,
     pub tame: bool,
     pub sitting: bool,
     /// The owner's UUID (tamed animals).
@@ -715,6 +737,12 @@ pub struct Extra {
     pub vector: [f64; 3],
     /// Active status effects: (effect id, ticks left, amplifier).
     pub effects: Vec<(&'static str, i32, i32)>,
+    /// The effects above given with `hideParticles`: no swirls for them.
+    pub hidden_effects: Vec<&'static str>,
+    /// `LivingEntity.DATA_EFFECT_PARTICLES` and `DATA_EFFECT_AMBIENCE_ID` as a
+    /// server gave them: the swirls around it, and whether they are all faint.
+    pub effect_particles: Vec<crate::particles::ParticleOptions>,
+    pub effect_ambient: bool,
     /// An invisible illusioner's mirror images.
     pub illusions: Option<illusioner::Illusions>,
     /// A villager's claimed bed head and meeting bell.
@@ -726,6 +754,8 @@ pub struct Extra {
     /// the spin the rope's torque gives it.
     pub leash: Option<leash::Holder>,
     pub leash_pending: Option<leash::Pending>,
+    /// The UUID of the player behind `Holder::Player` (host or guest).
+    pub leash_player: Option<[i32; 4]>,
     pub leash_spin: f64,
     /// More species scratch values.
     pub scratch: [i32; 4],
@@ -759,8 +789,9 @@ pub struct Extra {
     pub drop_chances: Option<Box<[f32; 8]>>,
     /// `Mob.leftHanded`.
     pub left_handed: bool,
-    /// The sound variant: index in the species' `*_sound_variant` registry.
-    pub sound_variant: u8,
+    /// The sound variant: index in the species' `*_sound_variant` registry
+    /// (`finalize::sound_variants`); None is the default, `classic`.
+    pub sound_variant: Option<u8>,
     /// `Zombie.canBreakDoors`.
     pub can_break_doors: bool,
     /// A goat's `IsScreamingGoat` and the horns it lost (left, right).
@@ -772,6 +803,8 @@ pub struct Extra {
     pub memories: Vec<(&'static str, i64, i64)>,
     /// A camel's `LAST_POSE_CHANGE_TICK`.
     pub pose_change_tick: i64,
+    /// `Entity.DATA_POSE` as a mob of a server has it (`sync::pose_id`).
+    pub pose: u8,
     /// The school leader a fish follows, and a tropical fish that swims alone.
     pub leader: Option<u32>,
     pub lone: bool,
@@ -815,6 +848,9 @@ pub struct Mob {
     pub previous_swell: i32,
     pub ambient_timer: i32,
     pub fall_distance: f64,
+    /// `Entity.pistonDeltas` and `pistonDeltasGameTime`: how far a moving
+    /// block has pushed this mob this tick (0.51 at most on any axis).
+    pub piston: horizon_world::piston_movement::PistonMovement,
     pub persistent: bool,
     /// `CustomName` (plain text) and `CustomNameVisible`.
     pub custom_name: Option<String>,
@@ -881,6 +917,18 @@ pub enum MobEvent {
         mob: u32,
         at: [f64; 3],
     },
+    /// `LivingEntity.baseTick`'s drowning damage: entity event 67, the
+    /// clients' `makeDrownParticles`.
+    Drown {
+        mob: u32,
+        at: [f64; 3],
+    },
+    /// `Level.broadcastEntityEvent` for a mob: guests run `sync::entity_event`.
+    EntityEvent {
+        mob: u32,
+        event: i8,
+        at: [f64; 3],
+    },
     Sound(&'static str, [f64; 3], f32, f32),
     /// `ChestBlockEntity.startOpen` / `stopOpen` by a copper golem: the
     /// chest's opener count goes up or down (interaction range 3).
@@ -904,6 +952,10 @@ pub enum MobEvent {
         slot: usize,
         stack: Option<crate::items::ItemStack>,
     },
+    /// `InfestedMobEffect.onMobHurt`: the mob was hurt while infested.
+    Infested {
+        mob: u32,
+    },
     /// `OfferFlowerGoal.stop`: the item goes to the target's antenna (saddle)
     /// slot if it is empty, as a guaranteed drop.
     Gift {
@@ -961,6 +1013,12 @@ pub enum MobEvent {
         target: Who,
         velocity: [f64; 3],
     },
+    /// `Entity.move(MoverType.SHULKER, delta)`: shift a target's position
+    /// (an opening shulker lifts what stands on its shell).
+    Shift {
+        target: Who,
+        delta: [f64; 3],
+    },
     /// `EvokerWololoSpellGoal`: a blue sheep turns red.
     Wololo {
         mob: u32,
@@ -973,7 +1031,17 @@ pub enum MobEvent {
         owner: u32,
     },
     Shoot([f64; 3], [f64; 3]),
-    Explode([f64; 3], f32),
+    /// The mob the `Explode` right after this comes from
+    /// (`ServerExplosion.source`), and whether it is a charged creeper: the
+    /// exploding creeper is already out of the mob list when the game applies
+    /// the blast, so its victims' loot cannot look it up.
+    ExplosionSource {
+        mob: u32,
+        charged: bool,
+    },
+    /// The centre, the radius and the kind of the mob blowing up (it may be
+    /// gone from the list by the time the blast is handled).
+    Explode([f64; 3], f32, Species),
     /// Melee or ranged damage to another mob.
     AttackMob {
         target: u32,
@@ -1009,6 +1077,24 @@ pub enum MobEvent {
         pos: [i32; 3],
         open: bool,
     },
+    /// `BreakDoorGoal.tick` at its end: the door is removed (`removeBlock`),
+    /// then level events 1021 and 2001 with the state that is left there.
+    BreakDoor {
+        pos: [i32; 3],
+    },
+    /// `Level.destroyBlockProgress` for a mob's crack on a block (`-1`
+    /// clears it).
+    DestroyProgress {
+        mob: u32,
+        pos: [i32; 3],
+        progress: i32,
+    },
+    /// `Level.levelEvent`: the game plays and sends the event.
+    LevelEvent {
+        id: i32,
+        pos: [i32; 3],
+        data: i32,
+    },
     /// Destroy a block, dropping nothing (sheep eating grass becomes dirt via SetBlock).
     BreakBlock {
         pos: [i32; 3],
@@ -1019,8 +1105,11 @@ pub enum MobEvent {
         at: [f64; 3],
         count: u32,
     },
-    /// Client particles about a mob's box (`particles::around_self`).
+    /// Client particles about a mob's box (`particles::around_self`) and the
+    /// entity event `event` that shows them, sent for mob `mob`.
     AroundSelf {
+        mob: u32,
+        event: i8,
         kind: &'static str,
         feet: [f64; 3],
         width: f64,
@@ -1106,6 +1195,13 @@ pub enum MobEvent {
         partner: u32,
         child: Option<([i32; 3], Option<u8>)>,
     },
+    /// `WorkAtComposter.useWorkstation`: a farmer at its composter makes
+    /// bread and composts seeds (the game applies it to the villager's
+    /// inventory and the block).
+    WorkAtComposter {
+        mob: u32,
+        pos: [i32; 3],
+    },
     /// A villager asks whether enough neighbours want an iron golem.
     GolemCheck {
         mob: u32,
@@ -1134,11 +1230,19 @@ pub enum MobEvent {
         target: Who,
         aggressive: bool,
     },
-    /// Drop the loot of a gift table (chicken eggs, armadillo scutes).
+    /// Drop the loot of a gift table (chicken eggs, sniffer seeds) with the
+    /// mob as `this` (`LivingEntity.dropFromGiftLootTable`).
     GiftLoot {
+        mob: u32,
         table: &'static str,
         at: [f64; 3],
     },
+    /// `Armadillo.customServerAiStep`: the armadillo sheds a scute.
+    ShedScute {
+        mob: u32,
+        at: [f64; 3],
+        pitch: f32,
+    },
     /// A lead snaps or loses its holder: the lead item drops when asked.
     LeashBreak {
         mob: u32,
@@ -1159,6 +1263,18 @@ pub enum MobEvent {
     DigParticles {
         at: [f64; 3],
     },
+    /// `Zombie.hurtServer`: a zombie hurt with a target in sight (its own,
+    /// else the attacker) may call a reinforcement against it on Hard.
+    Reinforcements {
+        mob: u32,
+        target: Who,
+    },
+    /// `LevelEvent.PARTICLES_DESTROY_BLOCK` (2001) at `pos` for the block at
+    /// `block`: a turtle's digging.
+    BlockBreakEffect {
+        pos: [i32; 3],
+        block: [i32; 3],
+    },
     /// `Warden.applyDarknessAround`: darkness for survival players nearby.
     Darkness {
         at: [f64; 3],
@@ -1231,6 +1347,8 @@ pub struct Seen {
     pub active_raid: bool,
     /// A copper golem's `openedChestPos` (`ContainerUser.hasContainerOpen`).
     pub opened_chest: Option<[i32; 3]>,
+    /// `isPassenger`.
+    pub passenger: bool,
     /// A villager's reputation of the player (`getPlayerReputation`).
     pub player_rep: i32,
     /// `isPushable` and pushed by others (`Entity.push(Entity)` moves it).
@@ -1251,6 +1369,18 @@ pub struct Seen {
     /// `MAX_HEALTH`, `JUMP_STRENGTH` and `MOVEMENT_SPEED` base values (a
     /// horse's breeding stock).
     pub stats: [f64; 3],
+    /// `Wolf.isInSittingPose`.
+    pub sitting: bool,
+    /// `Entity.isVehicle` or `isPassenger`.
+    pub ridden: bool,
+    /// The active effects, without namespace (`slowness`, `poison`...).
+    pub effects: Vec<&'static str>,
+}
+impl Seen {
+    /// `LivingEntity.hasEffect`, by id without namespace.
+    pub fn has_effect(&self, effect: &str) -> bool {
+        self.effects.contains(&effect)
+    }
 }
 impl Mob {
     pub fn burning_time(&self) -> f64 {
@@ -1267,6 +1397,10 @@ impl Mob {
             .max((f64::from(ticks) * self.burning_time()).ceil() as i32);
         self.ticks_frozen = 0;
     }
+    /// `Entity.isFullyFrozen`.
+    pub fn is_fully_frozen(&self) -> bool {
+        self.ticks_frozen >= crate::motion::PlayerMotion::TICKS_REQUIRED_TO_FREEZE
+    }
 
     /// What other mobs see of this one this tick (`player`: the player's
     /// UUID, which villagers' reputation is keyed by).
@@ -1306,6 +1440,7 @@ impl Mob {
             hurt_by: m.ai.last_hurt_by.map(|w| (w, m.ai.last_hurt_by_time)),
             active_raid: raider::has_active_raid(m),
             opened_chest: m.extra.opened_chest,
+            passenger: m.extra.mount.is_some(),
             player_rep: match (villager, player) {
                 (true, Some(uuid)) => villager::ext(m).map_or(0, |e| e.gossips.reputation(uuid)),
                 _ => 0,
@@ -1323,6 +1458,14 @@ impl Mob {
                 m.extra.vector[0],
                 m.attrs.speed,
             ],
+            sitting: m.extra.sitting,
+            ridden: m.rider.is_some() || m.extra.rider.is_some() || m.extra.mount.is_some(),
+            effects: m
+                .extra
+                .effects
+                .iter()
+                .map(|e| e.0.trim_start_matches("minecraft:"))
+                .collect(),
         }
     }
     /// `EntityType.getCategory`'s name.
@@ -1456,6 +1599,8 @@ pub struct PlayerView {
     pub off_hand: Option<Arc<str>>,
     pub head: Option<Arc<str>>,
     pub armor_cover: f32,
+    /// The Invisibility effect (`isInvisible`).
+    pub invisible: bool,
     pub spectator: bool,
     /// `PiglinAi.isWearingSafeArmor`: some golden armour.
     pub gold_armor: bool,
@@ -1467,6 +1612,8 @@ pub struct PlayerView {
     pub yaw: f32,
     /// The Hero of the Village effect.
     pub hero: bool,
+    /// The active effects, without namespace (`slowness`, `poison`...).
+    pub effects: Vec<&'static str>,
     /// The player's UUID (villagers' gossip is keyed by it).
     pub uuid: [i32; 4],
     /// The mobs on the player's team (`isAlliedTo`): combat targeting
@@ -1475,12 +1622,33 @@ pub struct PlayerView {
     /// A LAN guest: its own client moves it, and touching mobs push it there
     /// (`EntitySelector.pushableBy` on the client).
     pub remote: bool,
+    /// `isPassenger`.
+    pub passenger: bool,
+}
+impl PlayerView {
+    /// `LivingEntity.getVisibilityPercent` without the worn-skull scaling.
+    pub fn visibility_percent(&self) -> f64 {
+        let mut visibility = 1.0;
+        if self.sneaking {
+            visibility *= 0.8;
+        }
+        if self.invisible {
+            visibility *= 0.7 * f64::from(self.armor_cover).max(0.1);
+        }
+        visibility
+    }
+    /// `LivingEntity.hasEffect`, by id without namespace.
+    pub fn has_effect(&self, effect: &str) -> bool {
+        self.effects.contains(&effect)
+    }
 }
 #[derive(Clone)]
 pub struct MobWorld<'a> {
     pub world: &'a World,
     pub registry: &'a horizon_world::registry::BlockRegistry,
     pub facts: &'a BlockFacts,
+    /// Fluid states and flow facts, for the currents that push mobs.
+    pub fluid_tables: &'a crate::motion::FluidResources,
     pub movement: &'a horizon_world::movement_properties::BoundMovementProperties,
     pub collision: &'a BlockCollisionRegistry<'a>,
     pub data: &'a MobData,
@@ -1503,6 +1671,8 @@ pub struct MobWorld<'a> {
     pub biomes: &'a crate::biome::Biomes,
     /// The `mob_griefing` game rule.
     pub mob_griefing: bool,
+    /// The `mob_drops` game rule (`shouldDropLoot`).
+    pub mob_drops: bool,
     /// `getCurrentDifficultyAt` near the player.
     pub difficulty: spawning::LocalDifficulty,
     /// The End (its dimension type's monster spawn light rules).
@@ -1516,6 +1686,8 @@ pub struct MobWorld<'a> {
     pub teams: std::sync::Arc<Teams<'a>>,
     /// Item data (max stack sizes), when the host has it.
     pub items: Option<&'a crate::items::Items>,
+    /// `ChestBlockEntity.getOpenCount`: the players with each chest open.
+    pub lid_openers: &'a HashMap<(i32, i32, i32), i32>,
 }
 /// `Entity.getTeam` of the player and of the mobs on a team.
 #[derive(Clone, Debug, Default)]
@@ -1569,6 +1741,7 @@ impl Mob {
             // Mob.ambientSoundTime starts at 0.
             ambient_timer: 0,
             fall_distance: 0.0,
+            piston: Default::default(),
             persistent: false,
             random,
             ai: Box::default(),
@@ -1729,6 +1902,15 @@ impl Mob {
         {
             amount *= 0.75;
         }
+        // LivingEntity.hurtServer: `#freeze_hurts_extra_types` take five times.
+        if source.kind == DamageKind::Freeze
+            && matches!(
+                self.species(),
+                Species::Strider | Species::Blaze | Species::MagmaCube
+            )
+        {
+            amount *= 5.0;
+        }
         let (worn, worn_toughness) = self.worn_armor();
         if !source.bypasses_armor() && self.kind.armor + worn > 0.0 {
             // CombatRules.getDamageAfterAbsorb
@@ -1760,6 +1942,10 @@ impl Mob {
             self.health -= amount;
             self.hurt_time = 10;
         }
+        // Animal.actuallyHurt: damage taken ends love mode (`resetLove`).
+        if drops::is_animal(self.species()) {
+            self.extra.in_love = 0;
+        }
         self.last_damage = Some((source, i64::from(self.age)));
         if let Some(who) = source.attacker {
             self.ai.last_hurt_by = Some(who);
@@ -1786,7 +1972,7 @@ impl Mob {
             let dead = !self.alive();
             let sound = ai::voice_sounds(self)[if dead { 2 } else { 1 }];
             if !dead {
-                self.ambient_timer = -self.kind.ambient_interval;
+                self.ambient_timer = -self.ambient_interval();
             }
             if !sound.is_empty() {
                 let pitch = self.voice_pitch();
@@ -1797,6 +1983,15 @@ impl Mob {
                 }
             }
         }
+        if self.has_effect("minecraft:infested") {
+            self.outbox.push(MobEvent::Infested { mob: self.id });
+        }
+        // Squid.hurtServer: a squid hurt after a living entity hit it squirts ink.
+        if matches!(self.species(), Species::Squid | Species::GlowSquid)
+            && self.ai.last_hurt_by.is_some()
+        {
+            aquatic::spawn_ink(self);
+        }
         true
     }
     /// LivingEntity.knockback(power, xd, zd) towards the negative direction.
@@ -1847,7 +2042,8 @@ impl Mob {
     /// Movement speed attribute bonus (baby zombies, sprinting modifiers).
     /// MOVEMENT_SPEED including effects (speed +20%/level, slowness -15%/level).
     pub fn movement_speed(&self) -> f64 {
-        let mut v = strider::movement_speed(self, self.attrs.speed) * self.speed_bonus();
+        let mut v = strider::movement_speed(self, witch::speed(self, self.attrs.speed))
+            * self.speed_bonus();
         for (e, _, amp) in &self.extra.effects {
             match *e {
                 "minecraft:speed" => v *= 1.0 + 0.2 * f64::from(amp + 1),
@@ -1860,10 +2056,22 @@ impl Mob {
     pub fn has_effect(&self, effect: &str) -> bool {
         self.extra.effects.iter().any(|e| e.0 == effect)
     }
+    /// `LivingEntity.isCurrentlyGlowing`: the Glowing effect or the `Glowing` tag (on a
+    /// server's client, `glowing` holds shared flag 6 instead).
+    pub fn is_currently_glowing(&self) -> bool {
+        self.glowing || self.has_effect("minecraft:glowing")
+    }
     pub fn add_effect(&mut self, effect: &'static str, ticks: i32, amplifier: i32) {
         if let Some(e) = self.extra.effects.iter_mut().find(|e| e.0 == effect) {
-            e.1 = e.1.max(ticks);
-            e.2 = e.2.max(amplifier);
+            // MobEffectInstance.update: a stronger effect replaces with its
+            // own duration, an equal one only extends it; a weaker one is
+            // ignored (vanilla keeps it hidden behind the active one).
+            if amplifier > e.2 {
+                e.1 = ticks;
+                e.2 = amplifier;
+            } else if amplifier == e.2 && e.1 != -1 && (ticks == -1 || e.1 < ticks) {
+                e.1 = ticks;
+            }
         } else {
             self.extra.effects.push((effect, ticks, amplifier));
         }
@@ -1882,10 +2090,30 @@ impl Mob {
         let at = [self.position.x, self.eye_y(), self.position.z];
         events.push(MobEvent::Sound(event, at, 1.0, 1.0));
     }
+    /// `Mob.getAmbientSoundInterval`; `HappyGhast` waits six times as long
+    /// while it carries a passenger.
+    pub fn ambient_interval(&self) -> i32 {
+        let ridden = self.rider.is_some() || self.extra.rider.is_some();
+        if self.species() == Species::HappyGhast && ridden {
+            self.kind.ambient_interval * 6
+        } else {
+            self.kind.ambient_interval
+        }
+    }
     /// LivingEntity.getVoicePitch.
     pub fn voice_pitch(&mut self) -> f32 {
+        // HappyGhast.getVoicePitch: always 1.0, babies and all.
+        if self.species() == Species::HappyGhast {
+            return 1.0;
+        }
+        // ZombieVillager.getVoicePitch: babies are 2.0, not 1.5.
+        let baby = if self.species() == Species::ZombieVillager {
+            2.0
+        } else {
+            1.5
+        };
         let pitch = (self.random.next_float() - self.random.next_float()) * 0.2
-            + if self.is_baby() { 1.5 } else { 1.0 };
+            + if self.is_baby() { baby } else { 1.0 };
         // Bat.getVoicePitch: a little lower.
         if self.species() == Species::Bat {
             pitch * 0.95
@@ -1996,6 +2224,7 @@ pub fn render_model(
                     layer: overlay,
                     color: 0xFFFF_FFFF,
                     light,
+                    glint_uv: [0.0, 0.0],
                 });
             }
         }
@@ -2130,7 +2359,7 @@ mod lighting_tests {
     #[test]
     fn packed_normal_uses_native_snorm_bytes_without_changing_vertex_offsets() {
         assert_eq!(std::mem::offset_of!(Vertex, normal), 32);
-        assert_eq!(std::mem::size_of::<Vertex>(), 36);
+        assert_eq!(std::mem::size_of::<Vertex>(), 44);
         let part = plane([0.0, 1.0, 0.0]);
         assert_eq!(
             part.polygons[0].vertex_normal(ModelNormals::new(Mat4::from_scale(Vec3::ZERO))),
diff --git a/crates/horizon-client/src/mobs/ai.rs b/crates/horizon-client/src/mobs/ai.rs
index 2676c3a37..ad130ea68 100644
--- a/crates/horizon-client/src/mobs/ai.rs
+++ b/crates/horizon-client/src/mobs/ai.rs
@@ -106,6 +106,7 @@ pub enum Family {
     Strider,
     Bat,
     Bee,
+    PolarBear,
 }
 pub fn family(s: Species) -> Family {
     use Species as S;
@@ -167,6 +168,7 @@ pub fn family(s: Species) -> Family {
         S::Strider => Family::Strider,
         S::Bat => Family::Bat,
         S::Bee => Family::Bee,
+        S::PolarBear => Family::PolarBear,
         _ => Family::Generic,
     }
 }
@@ -183,6 +185,35 @@ pub fn register(m: &mut Mob) {
             if m.species() == Species::Rabbit {
                 super::rabbit::register(m);
             }
+            if m.species() == Species::Frog {
+                // `Frog()`: SmoothSwimmingMoveControl(85, 10, 0.02, 0.1, true).
+                // The speed attribute is 1.0, so the controller's scaling is
+                // what keeps a frog at a walking pace on land.
+                m.ai.mov.kind = super::control::MoveKind::SmoothSwimming {
+                    max_turn_x: 85.0,
+                    max_turn_y: 10.0,
+                    in_water: 0.02,
+                    outside: 0.1,
+                    gravity: true,
+                };
+            }
+            if m.species() == Species::Turtle {
+                super::turtle::register(m);
+            }
+            if m.species() == Species::Frog {
+                // `Frog()`: SmoothSwimmingMoveControl(85, 10, 0.02, 0.1, true).
+                // The frog's movement speed is 1.0, so the controller's 0.1
+                // outside-water speed is what keeps a walking frog at
+                // vanilla's pace; the plain ground controller walks ten
+                // times too fast (#2213).
+                m.ai.mov.kind = super::control::MoveKind::SmoothSwimming {
+                    max_turn_x: 85.0,
+                    max_turn_y: 10.0,
+                    in_water: 0.02,
+                    outside: 0.1,
+                    gravity: true,
+                };
+            }
         }
         Family::Inert => {}
         Family::Witch => super::witch::register(m),
@@ -224,6 +255,7 @@ pub fn register(m: &mut Mob) {
         Family::Strider => super::strider::register(m),
         Family::Bat => super::bat::register(m),
         Family::Bee => super::bee::register(m),
+        Family::PolarBear => super::polar_bear::register(m),
     }
     // FloatGoal's constructor lets the navigation float, as do the
     // constructors of these brain-driven and flying mobs. A floater rises
@@ -301,12 +333,30 @@ fn generic(m: &mut Mob) {
         m.ai.targets.add(1, HurtByTarget::new());
         m.ai.targets.add(2, NearestTarget::player(true));
     } else {
+        if m.kind.species == Species::Goat {
+            // GoatAi's idle and core behaviours (the ram and long jump
+            // activities are not here): panic 2.0, AnimalMakeLove, tempting
+            // with goat_food and baby follow at 1.25, then stroll.
+            g.add(0, Float);
+            g.add(1, Panic::new(2.0));
+            g.add(2, Breed::new(1.0));
+            g.add(3, Tempt::new(1.25, m.kind.food.clone(), false));
+            g.add(4, FollowParent::new(1.25));
+            g.add(5, Stroll::avoiding_water(1.0));
+            g.add(6, LookAtPlayer::new(6.0));
+            g.add(7, RandomLookAround::default());
+            return;
+        }
         g.add(0, Float);
         let rabbit = m.kind.species == Species::Rabbit;
         g.add(1, Panic::new(if rabbit { 2.2 } else { 1.25 }));
         g.add(5, Stroll::avoiding_water(if rabbit { 0.6 } else { 1.0 }));
         g.add(6, LookAtPlayer::new(6.0));
         g.add(7, RandomLookAround::default());
+        if m.kind.species == Species::Armadillo {
+            // Armadillo's constructor: pickNextScuteDropTime.
+            m.extra.egg_time = next_scute_time(m);
+        }
     }
 }
 /// Subclasses of `net.minecraft.world.entity.monster.Monster`.
@@ -413,6 +463,7 @@ pub fn tick(
     super::axolotl::tick_animation(m);
     m.anim.end_tick(m.ai.swinging);
     tick_swing(m);
+    flower_contact_effects(m, w);
     if m.species() == Species::CopperGolem {
         // CopperGolem.tick: updateWeathering after the living tick.
         super::copper_golem::update_weathering(m, w, level_random, events);
@@ -441,6 +492,36 @@ pub fn tick_swing(m: &mut Mob) {
     }
     m.anim.attack_anim = m.ai.swing_time as f32 / 6.0;
 }
+/// `Entity.isInRain`: rain at the block position, or at the top of the box.
+pub(super) fn in_rain(m: &Mob, w: &MobWorld) -> bool {
+    let (x, y, z) = (
+        m.position.x.floor() as i32,
+        m.position.y.floor() as i32,
+        m.position.z.floor() as i32,
+    );
+    let top = (m.position.y + f64::from(m.height())).floor() as i32;
+    w.raining_at(x, y, z) || w.raining_at(x, top, z)
+}
+/// `LivingEntity.baseTick` refills a breather's air by 4, then
+/// `Axolotl.handleAirSupply` (unless the mob has no AI): water or rain fills
+/// it, anywhere else it runs down from the pre-tick value, and at -20 the
+/// axolotl dries out.
+fn axolotl_air_supply(m: &mut Mob, w: &MobWorld) {
+    let before = m.air;
+    m.air = (m.air + 4).min(super::axolotl::MAX_AIR);
+    if m.no_ai {
+        return;
+    }
+    if m.fluids.in_water || in_rain(m, w) {
+        m.air = super::axolotl::MAX_AIR;
+    } else {
+        m.air = before - 1;
+        if m.air <= -20 {
+            m.air = 0;
+            m.damage(2.0, Damage::of(DamageKind::DryOut));
+        }
+    }
+}
 /// Entity.baseTick + LivingEntity.baseTick + Mob.baseTick.
 fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     m.was_eye_in_water = m.fluids.eye_in_water;
@@ -459,8 +540,9 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         );
         m.damage(fire, Damage::of(DamageKind::InFire));
     }
-    // Fire: water extinguishes, lava ignites, burning hurts every second.
-    if m.fluids.in_water && m.fire_ticks > 0 {
+    // Fire: water or rain (Entity.isInRain) extinguishes, lava ignites,
+    // burning hurts every second.
+    if m.fire_ticks > 0 && (m.fluids.in_water || in_rain(m, w)) {
         m.fire_ticks = 0;
         events.push(MobEvent::Sound(
             "entity.generic.extinguish_fire",
@@ -489,18 +571,25 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     }
     m.first_tick = false;
     if m.alive() {
-        // LivingEntity.baseTick: suffocation inside full blocks.
+        // LivingEntity.baseTick: suffocation inside full blocks. Entity.isInWall
+        // is false under noPhysics, which Vex.tick holds while it ticks.
         let (ex, ey, ez) = (
             m.position.x.floor() as i32,
             m.eye_y().floor() as i32,
             m.position.z.floor() as i32,
         );
         let at_eye = w.facts.get(w.world.block(ex, ey, ez));
-        if at_eye.full_collision && at_eye.solid_render && m.width() < 1.0 {
+        if at_eye.full_collision
+            && at_eye.solid_render
+            && m.width() < 1.0
+            && m.species() != Species::Vex
+        {
             m.damage(1.0, Damage::of(DamageKind::InWall));
         }
         // Air supply and drowning (WaterAnimal.handleAirSupply for aquatic mobs).
-        if m.kind.flags.needs_water {
+        if m.species() == Species::Axolotl {
+            axolotl_air_supply(m, w);
+        } else if m.kind.flags.needs_water {
             if !m.fluids.in_water {
                 m.air -= 1;
                 if m.air == -20 {
@@ -514,17 +603,20 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
             m.air -= 1;
             if m.air == -20 {
                 m.air = 0;
+                events.push(MobEvent::Drown {
+                    mob: m.id,
+                    at: [m.position.x, m.position.y, m.position.z],
+                });
                 m.damage(2.0, Damage::of(DamageKind::Drown));
             }
         } else if m.air < 300 {
             m.air = (m.air + 4).min(300);
         }
 
-        if m.kind.flags.water_sensitive
-            && (m.fluids.in_water || w.raining && w.can_see_sky(ex, ey, ez))
-        {
+        if m.kind.flags.water_sensitive && (m.fluids.in_water || in_rain(m, w)) {
             m.damage(1.0, Damage::of(DamageKind::Drown));
         }
+        freeze_tick(m, w);
     }
     tick_effects(m);
     if m.species() == Species::Illusioner {
@@ -547,13 +639,64 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         let t = m.ambient_timer;
         m.ambient_timer += 1;
         if roll < t {
-            m.ambient_timer = -m.kind.ambient_interval;
+            m.ambient_timer = -m.ambient_interval();
             play_ambient(m, w, events);
         }
     }
     // Entity.baseTick ends with Leashable.tickLeash.
     super::leash::tick(m, w, events);
 }
+/// `LivingEntity.aiStep`'s "freezing" with `InsideBlockEffectType.FREEZE`:
+/// powder snow builds `ticks_frozen` up, anywhere else it melts twice as
+/// fast, and a fully frozen mob takes one freeze damage every 40 ticks.
+fn freeze_tick(m: &mut Mob, w: &MobWorld) {
+    let in_snow = in_powder_snow(m, w);
+    if !in_snow && m.ticks_frozen == 0 {
+        return;
+    }
+    let can_freeze = can_freeze(m, w);
+    if in_snow && can_freeze {
+        m.ticks_frozen =
+            (m.ticks_frozen + 1).min(crate::motion::PlayerMotion::TICKS_REQUIRED_TO_FREEZE);
+    } else {
+        m.ticks_frozen = (m.ticks_frozen - 2).max(0);
+    }
+    if m.age.is_multiple_of(40) && m.is_fully_frozen() && can_freeze {
+        m.damage(1.0, Damage::of(DamageKind::Freeze));
+    }
+}
+/// Whether the mob's box (shrunk by `1.0E-5`, as in `Entity.checkInsideBlocks`)
+/// touches powder snow.
+fn in_powder_snow(m: &Mob, w: &MobWorld) -> bool {
+    let b = m.bounds().deflate(Vec3::new(1e-5, 1e-5, 1e-5));
+    let (min, max) = (b.min_position(), b.max_position());
+    for x in min.x.floor() as i32..=max.x.floor() as i32 {
+        for y in min.y.floor() as i32..=max.y.floor() as i32 {
+            for z in min.z.floor() as i32..=max.z.floor() as i32 {
+                if &*w.facts.get(w.world.block(x, y, z)).name == "minecraft:powder_snow" {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}
+/// `LivingEntity.canFreeze`: not a `#freeze_immune_entity_types` mob and no
+/// worn piece in `#freeze_immune_wearables`.
+fn can_freeze(m: &Mob, w: &MobWorld) -> bool {
+    if w.data
+        .entity_has("minecraft:freeze_immune_entity_types", &m.kind.id)
+    {
+        return false;
+    }
+    let immune = w
+        .items
+        .and_then(|i| i.item_tags.get("minecraft:freeze_immune_wearables"));
+    ![&m.extra.head, &m.extra.chest, &m.extra.legs, &m.extra.feet]
+        .into_iter()
+        .flatten()
+        .any(|item| immune.is_some_and(|t| t.contains(&**item)))
+}
 /// `Mob.playAmbientSound` on demand: a spawn egg or a mob bucket just placed `m`.
 pub fn ambient_sound(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     play_ambient(m, w, events);
@@ -641,7 +784,7 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: &
     }
     // AbstractHorse.aiStep: the tail swishes now and then (moveTail).
     if super::equine::is_equine(m.species()) {
-        let _ = m.random.next_int_bound(200);
+        super::equine::tail_tick(m);
     }
     // Monster.aiStep: updateNoActionTime (Raider: always +2).
     if is_monster(m.species())
@@ -668,6 +811,9 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: &
     // serverAiStep has no goals, so it only falls and is pushed.
     let immobile = (m.species() == Species::Ravager && super::ravager::immobile(m))
         || m.species() == Species::Mannequin;
+    if m.species() == Species::Piglin && m.alive() {
+        super::piglin::celebrate(m, w);
+    }
     if m.alive() && !immobile {
         server_ai_step(m, w, level_random, events);
     } else {
@@ -712,6 +858,14 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: &
             // setAge at the age boundary: refreshDimensions.
             if m.extra.age >= 0 {
                 m.fudge_position_after_size_change(w, bw, bh);
+                // Turtle.ageBoundaryReached: a grown turtle drops a scute.
+                if m.species() == Species::Turtle {
+                    events.push(MobEvent::GiftLoot {
+                        mob: m.id,
+                        table: "minecraft:gameplay/turtle_grow",
+                        at: [m.position.x, m.position.y, m.position.z],
+                    });
+                }
             }
         } else if m.extra.age > 0 {
             m.extra.age -= 1;
@@ -746,7 +900,7 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: &
     if m.kind.flags.burns_in_day && m.alive() && sun_burn_tick(m, w) && m.extra.head.is_none() {
         m.ignite_for_ticks(160);
     }
-    species_ai_step(m, w, events);
+    species_ai_step(m, w, level_random, events);
 }
 impl Mob {
     /// LivingEntity.isPushable (and the push it takes from `Entity.push(Entity)`):
@@ -847,7 +1001,7 @@ fn sun_burn_tick(m: &mut Mob, w: &MobWorld) -> bool {
         m.position.z.floor() as i32,
     );
     let br = w.brightness(x, y, z);
-    let wet = m.fluids.in_water || w.raining && w.can_see_sky(x, y, z);
+    let wet = m.fluids.in_water || in_rain(m, w);
     br > 0.5 && m.random.next_float() * 30.0 < (br - 0.4) * 2.0 && !wet && w.can_see_sky(x, y, z)
 }
 /// Mob.serverAiStep
@@ -930,9 +1084,31 @@ fn server_ai_step(
     }
     m.jump_control_tick();
 }
+/// `Armadillo.pickNextScuteDropTime`: 5 to 10 minutes.
+fn next_scute_time(m: &mut Mob) -> i32 {
+    m.random.next_int_bound(20 * 60 * 5).unwrap_or(0) + 20 * 60 * 5
+}
+/// `Armadillo.customServerAiStep`: the scute timer keeps counting down and is
+/// only reset once `shouldDropLoot` (not a baby, `mob_drops` on) lets it shed.
+fn armadillo_server_ai_step(m: &mut Mob, mob_drops: bool, events: &mut Vec<MobEvent>) {
+    if !m.alive() {
+        return;
+    }
+    m.extra.egg_time -= 1;
+    if m.extra.egg_time <= 0 && !m.is_baby() && mob_drops {
+        let pitch = (m.random.next_float() - m.random.next_float()) * 0.2 + 1.0;
+        events.push(MobEvent::ShedScute {
+            mob: m.id,
+            at: [m.position.x, m.position.y, m.position.z],
+            pitch,
+        });
+        m.extra.egg_time = next_scute_time(m);
+    }
+}
 fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) {
     match m.species() {
         Species::Rabbit => super::rabbit::server_ai_step(m),
+        Species::Armadillo => armadillo_server_ai_step(m, cx.w.mob_drops, cx.events),
         Species::Sheep => {}
         Species::Zombie
         | Species::Husk
@@ -944,6 +1120,7 @@ fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) {
         | Species::Parched
         | Species::WitherSkeleton
         | Species::ZombifiedPiglin => undead::custom_server_ai_step(m, cx),
+        Species::Vindicator => super::illager::vindicator_server_ai_step(m),
         Species::Enderman => super::enderman::custom_server_ai_step(m, cx),
         Species::Blaze => super::nether::blaze_server_ai_step(m, cx),
         Species::ElderGuardian => super::guardian::elder_server_ai_step(m, cx),
@@ -955,7 +1132,12 @@ fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) {
         _ => {}
     }
 }
-fn species_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
+fn species_ai_step(
+    m: &mut Mob,
+    w: &MobWorld,
+    level_random: &mut LegacyRandom,
+    events: &mut Vec<MobEvent>,
+) {
     if family(m.species()) == Family::Aquatic {
         aquatic::ai_step(m, w, events);
     }
@@ -978,6 +1160,7 @@ fn species_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         Species::Wither => super::wither::ai_step(m, w, events),
         Species::Allay => super::allay::ai_step(m),
         Species::Bee => super::bee::ai_step(m, w),
+        Species::PolarBear => super::polar_bear::ai_step(m, w),
         Species::Breeze => super::breeze::ai_step(m),
         Species::Sniffer => super::sniffer::ai_step(m, events),
         Species::HappyGhast => super::happy_ghast::ai_step(m, w),
@@ -988,7 +1171,7 @@ fn species_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         }
         Species::Shulker => {
             super::shulker::tick(m, w, events);
-            super::shulker::ai_step(m, w, events);
+            super::shulker::ai_step(m, w, level_random, events);
         }
         Species::SnowGolem => super::golem::snow_ai_step(m, w, events),
         Species::CopperGolem => super::copper_golem::ai_step(m, w, events),
@@ -999,6 +1182,7 @@ fn species_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         }
         Species::Nautilus | Species::ZombieNautilus => super::nautilus::ai_step(m, w, events),
         Species::Chicken => farm::chicken_ai_step(m, w, events),
+        Species::Turtle => super::turtle::ai_step(m, w, events),
         Species::Sheep if m.extra.anim_ticks > 0 => {
             m.extra.anim_ticks -= 1;
         }
@@ -1017,6 +1201,19 @@ pub fn despawn_check(m: &mut Mob, w: &MobWorld) -> bool {
     }
     true
 }
+/// `Mob.requiresCustomPersistence` and its overrides: a passenger or a leashed
+/// mob, a raider in a raid, an enderman carrying a block, a tame nautilus, a
+/// sulfur cube holding a block or let out of a bucket. The spawn caps do not
+/// count these mobs either (`NaturalSpawner.createState`).
+pub fn requires_custom_persistence(m: &Mob) -> bool {
+    super::riders::keeps_alive(m)
+        || m.extra.leash.is_some()
+        || super::raider::state(m).is_some_and(|s| s.raid_id.is_some())
+        || m.species() == Species::Enderman && m.extra.carried.is_some()
+        || super::nautilus::is_nautilus(m.species()) && m.extra.tame
+        || m.species() == Species::SulfurCube
+            && (super::sulfur_cube::has_body(m) || m.extra.scratch[3] != 0)
+}
 /// Mob.checkDespawn, before the tick (players are the only despawn
 /// reference). Returns false when the mob is discarded.
 fn check_despawn(m: &mut Mob, w: &MobWorld) -> bool {
@@ -1032,12 +1229,7 @@ fn check_despawn(m: &mut Mob, w: &MobWorld) -> bool {
         return true;
     };
     let d = m.distance_sqr(p);
-    // requiresCustomPersistence: raiders in a raid, a tame nautilus, a sulfur
-    // cube holding a block or let out of a bucket.
-    let persistent = m.persistent
-        || super::nautilus::is_nautilus(m.species()) && m.extra.tame
-        || m.species() == Species::SulfurCube
-            && (super::sulfur_cube::has_body(m) || m.extra.scratch[3] != 0);
+    let persistent = m.persistent || requires_custom_persistence(m);
     // removeWhenFarAway: animals, villagers, golems, patrols and raiders,
     // zombie villagers being cured and ridden mobs stay.
     let creature = m.kind.category == "creature";
@@ -1324,6 +1516,11 @@ pub fn after_hurt(m: &mut Mob, source: &Damage) {
         Species::Warden => super::warden::hurt(m, source),
         Species::Wolf => super::tame::after_hurt(m, source),
         Species::Nautilus | Species::ZombieNautilus => super::nautilus::after_hurt(m, source),
+        Species::Zombie
+        | Species::Husk
+        | Species::Drowned
+        | Species::ZombieVillager
+        | Species::ZombifiedPiglin => super::undead::after_hurt(m, source),
         // NeutralMob: an iron golem hit by the player stays angry a while.
         // PiglinAi.wasHurtBy: drop what is being admired, no admiring for
         // a while after a player's hit, and anger.
@@ -1464,30 +1661,89 @@ pub fn custom_travel(m: &mut Mob, w: &MobWorld, input: Vec3, events: &mut Vec<Mo
     }
 }
 
+/// `Entity.applyEffectsFromBlocks` for the flowers that give an effect:
+/// `WitherRoseBlock.entityInside` (wither for 40 ticks on a living mob that
+/// can take it, not in peaceful) and `EyeblossomBlock.entityInside` (poison
+/// for 25 ticks on a bee, when the open flower attracts bees). The blocks
+/// are those the mob's box touches where it started the tick and where it
+/// ended.
+fn flower_contact_effects(m: &mut Mob, w: &MobWorld) {
+    if !m.alive() || w.difficulty.effective == 0.0 {
+        return;
+    }
+    let half = f64::from(m.width()) / 2.0 - 1.0e-5;
+    let height = f64::from(m.height()) - 1.0e-5;
+    let mut visited: Vec<[i32; 3]> = Vec::new();
+    for at in [m.previous, m.position] {
+        let cells = |lo: f64, hi: f64| lo.floor() as i32..=hi.floor() as i32;
+        for x in cells(at.x - half, at.x + half) {
+            for y in cells(at.y + 1.0e-5, at.y + height) {
+                for z in cells(at.z - half, at.z + half) {
+                    let p = [x, y, z];
+                    if visited.contains(&p) {
+                        continue;
+                    }
+                    match w.block_name(x, y, z) {
+                        "minecraft:wither_rose" => {
+                            // isInvulnerableTo(wither): the invulnerable time
+                            // after a hit; WitherBoss and WitherSkeleton
+                            // refuse the effect (`canBeAffected`).
+                            if m.invulnerable <= 0
+                                && !m.invulnerable_flag
+                                && !matches!(m.species(), Species::Wither | Species::WitherSkeleton)
+                            {
+                                m.add_effect("minecraft:wither", 40, 0);
+                            }
+                        }
+                        "minecraft:open_eyeblossom"
+                            if m.species() == Species::Bee
+                                && super::bee::attracts_bees(w, p)
+                                && !m.has_effect("minecraft:poison") =>
+                        {
+                            m.add_effect("minecraft:poison", 25, 0);
+                        }
+                        _ => continue,
+                    }
+                    visited.push(p);
+                }
+            }
+        }
+    }
+}
+
 /// MobEffect ticking for the effects mobs receive (poison, wither, regeneration).
 fn tick_effects(m: &mut Mob) {
     let mut effects = std::mem::take(&mut m.extra.effects);
     for (effect, ticks, amp) in &mut effects {
         let interval = |base: i32| (base >> (*amp).max(0)).max(1);
+        // MobEffectInstance.tickServer: an infinite (-1) effect times its
+        // ticks by the mob's tickCount and never counts down.
+        let infinite = *ticks == -1;
+        let count = if infinite { m.age as i32 } else { *ticks };
         match *effect {
             "minecraft:poison"
-                if *ticks % interval(25) == 0 && !m.kind.flags.undead && m.health > 1.0 =>
+                if count % interval(25) == 0 && !m.kind.flags.undead && m.health > 1.0 =>
             {
                 m.damage(1.0, Damage::of(DamageKind::Magic));
             }
-            "minecraft:wither" if *ticks % interval(40) == 0 => {
+            "minecraft:wither" if count % interval(40) == 0 => {
                 m.damage(1.0, Damage::of(DamageKind::Magic));
             }
             "minecraft:regeneration"
-                if *ticks % interval(50) == 0 && !m.kind.flags.undead && m.alive() =>
+                if count % interval(50) == 0 && !m.kind.flags.undead && m.alive() =>
             {
                 m.health = (m.health + 1.0).min(m.attrs.max_health);
             }
             _ => {}
         }
-        *ticks -= 1;
+        if !infinite {
+            *ticks -= 1;
+        }
     }
-    effects.retain(|e| e.1 > 0);
+    effects.retain(|e| e.1 > 0 || e.1 == -1);
+    m.extra
+        .hidden_effects
+        .retain(|h| effects.iter().any(|e| e.0 == *h));
     m.extra.effects = effects;
 }
 
@@ -1568,8 +1824,20 @@ pub fn step_sound(
         S::Husk => quiet("entity.husk.step"),
         S::Drowned => quiet("entity.drowned.step"),
         S::ZombieVillager => quiet("entity.zombie_villager.step"),
-        S::CamelHusk => Some(("entity.camel_husk.step", 0.4, 1.0)),
-        S::Camel => Some(("entity.camel.step", 1.0, 1.0)),
+        // Camel.playStepSound and CamelHusk.playStepSound: sand and concrete
+        // powder have their own step.
+        S::CamelHusk | S::Camel => {
+            let sand = w.has_tag(
+                "minecraft:camel_sand_step_sound_blocks",
+                &w.facts.get(state).name,
+            );
+            Some(match (m.species(), sand) {
+                (S::Camel, true) => ("entity.camel.step_sand", 1.0, 1.0),
+                (S::Camel, false) => ("entity.camel.step", 1.0, 1.0),
+                (_, true) => ("entity.camel_husk.step_sand", 0.4, 1.0),
+                (_, false) => ("entity.camel_husk.step", 0.4, 1.0),
+            })
+        }
         S::IronGolem => Some(("entity.iron_golem.step", 1.0, 1.0)),
         // CopperGolem.playStepSound: its oxidation level's step.
         S::CopperGolem => Some((super::copper_golem::sound(m, "step"), 1.0, 1.0)),
@@ -1648,3 +1916,41 @@ mod despawn_tests {
         }
     }
 }
+
+#[cfg(test)]
+mod frog_tests {
+    use super::*;
+    use crate::mobs::MobTypes;
+    use crate::mobs::control::MoveKind;
+    use std::sync::Arc;
+
+    /// `Frog()`: `new SmoothSwimmingMoveControl<>(this, 85, 10, 0.02F, 0.1F, true)`.
+    /// The frog's movement speed is 1.0, so the controller's 0.1 outside-water
+    /// speed is what keeps a walking frog at vanilla's pace. The plain ground
+    /// controller walks it ten times too fast, which is the jitter, the
+    /// teleporting and the flying of #2213.
+    #[test]
+    fn a_frog_walks_at_the_vanilla_speed() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("entity-types.json").exists() {
+            return;
+        }
+        let data = MobTypes::load(&root).unwrap();
+        let kind = Arc::new(data.types.get("minecraft:frog").unwrap().clone());
+        assert_eq!(kind.speed, 1.0, "the frog's movement speed attribute");
+        let mut m = Mob::new(1, kind, Vec3::new(0.0, 4.0, 0.0), 0.0);
+        register(&mut m);
+        assert_eq!(
+            m.ai.mov.kind,
+            MoveKind::SmoothSwimming {
+                max_turn_x: 85.0,
+                max_turn_y: 10.0,
+                in_water: 0.02,
+                outside: 0.1,
+                gravity: true,
+            }
+        );
+    }
+}
diff --git a/crates/horizon-client/src/mobs/anim.rs b/crates/horizon-client/src/mobs/anim.rs
index b81f224ae..a4c27960e 100644
--- a/crates/horizon-client/src/mobs/anim.rs
+++ b/crates/horizon-client/src/mobs/anim.rs
@@ -197,7 +197,8 @@ pub fn state(m: &Mob, alpha: f32) -> State {
     let walking = m.alive() && !m.extra.passenger;
     State {
         pos: if walking {
-            m.limb_position - m.limb_speed * (1.0 - alpha)
+            // WalkAnimationState.position(partial): babies' legs move 3 times as far.
+            (m.limb_position - m.limb_speed * (1.0 - alpha)) * if m.is_baby() { 3.0 } else { 1.0 }
         } else {
             0.0
         },
@@ -248,18 +249,24 @@ pub enum ArmPose {
 pub fn humanoid_pub(p: &mut Poses, s: &State, _m: &Mob) {
     humanoid(p, s, &Hum::new(ArmPose::Empty, ArmPose::Empty));
 }
-/// `AnimationUtils.swingWeaponDown` with the right arm as the main arm.
-pub(super) fn swing_weapon_down(p: &mut Poses, swing: f32, age: f32) {
+/// `AnimationUtils.swingWeaponDown`: the main arm swings down, the other
+/// one hangs and bobs.
+pub(super) fn swing_weapon_down(p: &mut Poses, swing: f32, age: f32, left_main: bool) {
     let attack2 = (swing * PI).msin();
     let attack = ((1.0 - (1.0 - swing) * (1.0 - swing)) * PI).msin();
+    let (main, off) = if left_main {
+        ("left_arm", "right_arm")
+    } else {
+        ("right_arm", "left_arm")
+    };
     p.zrot("right_arm", 0.0);
     p.zrot("left_arm", 0.0);
     p.yrot("right_arm", PI / 20.0);
     p.yrot("left_arm", -PI / 20.0);
-    p.xrot("right_arm", -1.884_955_8 + (age * 0.09).mcos() * 0.15);
-    p.xrot("left_arm", -0.0 + (age * 0.19).mcos() * 0.5);
-    p.get("right_arm")[3] += attack2 * 2.2 - attack * 0.4;
-    p.get("left_arm")[3] += attack2 * 1.2 - attack * 0.4;
+    p.xrot(main, -1.884_955_8 + (age * 0.09).mcos() * 0.15);
+    p.xrot(off, -0.0 + (age * 0.19).mcos() * 0.5);
+    p.get(main)[3] += attack2 * 2.2 - attack * 0.4;
+    p.get(off)[3] += attack2 * 1.2 - attack * 0.4;
     bob(p, "right_arm", age, 1.0);
     bob(p, "left_arm", age, -1.0);
 }
@@ -286,6 +293,8 @@ pub struct Hum {
     pub using_item: bool,
     /// The arm the current swing moves (`Some(true)` for the right one).
     pub swing_right_arm: Option<bool>,
+    /// `mainArm` is the left one (`Mob.isLeftHanded`): a mob's swing uses it.
+    pub left_main: bool,
 }
 impl Hum {
     pub fn new(right: ArmPose, left: ArmPose) -> Self {
@@ -303,6 +312,7 @@ impl Hum {
             swim: 0.0,
             using_item: false,
             swing_right_arm: None,
+            left_main: false,
         }
     }
 }
@@ -315,7 +325,7 @@ impl ArmPose {
     }
 }
 /// `AnimationUtils.animateCrossbowHold`.
-fn crossbow_hold(p: &mut Poses, hx: f32, hy: f32, in_right: bool) {
+pub(super) fn crossbow_hold(p: &mut Poses, hx: f32, hy: f32, in_right: bool) {
     let (hold, shoot) = if in_right {
         ("right_arm", "left_arm")
     } else {
@@ -327,7 +337,7 @@ fn crossbow_hold(p: &mut Poses, hx: f32, hy: f32, in_right: bool) {
     p.xrot(shoot, -1.5 + hx);
 }
 /// `AnimationUtils.animateCrossbowCharge`.
-fn crossbow_charge(p: &mut Poses, max: f32, ticks: f32, in_right: bool) {
+pub(super) fn crossbow_charge(p: &mut Poses, max: f32, ticks: f32, in_right: bool) {
     let (hold, pull) = if in_right {
         ("right_arm", "left_arm")
     } else {
@@ -418,13 +428,17 @@ pub(super) fn humanoid(p: &mut Poses, s: &State, h: &Hum) {
             pose_arm(p, h.right, true, h);
         }
     }
-    // setupAttackAnimation (WHACK swing with the right arm).
+    // setupAttackAnimation (WHACK swing with the arm of the swinging hand).
     let hx = p.get("head")[3];
     let swing = s.swing;
+    let swing_left = h.swing_right_arm.map_or(h.left_main, |right| !right);
     if swing > 0.0 && h.weapon_swing {
-        swing_weapon_down(p, swing, s.age);
+        swing_weapon_down(p, swing, s.age, h.left_main);
     } else if swing > 0.0 {
-        let body_y = (swing.sqrt() * PI * 2.0).msin() * 0.2;
+        let mut body_y = (swing.sqrt() * PI * 2.0).msin() * 0.2;
+        if swing_left {
+            body_y = -body_y;
+        }
         p.yrot("body", body_y);
         let age_scale = if s.baby { 0.5 } else { 1.0 };
         {
@@ -444,7 +458,7 @@ pub(super) fn humanoid(p: &mut Poses, s: &State, h: &Hum) {
         let eased = 1.0 - (1.0 - swing).powi(4);
         let aa = (eased * PI).msin();
         let bb = (swing * PI).msin() * -(hx - 0.7) * 0.75;
-        let r = p.get("right_arm");
+        let r = p.get(if swing_left { "left_arm" } else { "right_arm" });
         r[3] -= aa * 1.2 + bb;
         r[4] += body_y * 2.0;
         r[5] += (swing * PI).msin() * -0.4;
@@ -652,6 +666,7 @@ pub fn setup(
             } else {
                 Hum::new(main, ArmPose::Empty)
             };
+            h.left_main = m.main_arm_left();
             h.zombie = Some(m.ai.aggressive);
             h.holding = m.extra.main_hand.is_some();
             h.crouching = m.extra.crouching;
@@ -715,6 +730,7 @@ pub fn setup(
             h.swim = m.extra.swim.amount(s.partial);
             h.using_item = m.extra.using_item > 0;
             h.swing_right_arm = m.extra.swing_right_arm;
+            h.left_main = m.main_arm_left();
             humanoid(p, s, &h);
             if m.ai.aggressive && !bow {
                 // SkeletonModel melee pose.
diff --git a/crates/horizon-client/src/mobs/animal_brain.rs b/crates/horizon-client/src/mobs/animal_brain.rs
index bd0eb9c90..d928c34ee 100644
--- a/crates/horizon-client/src/mobs/animal_brain.rs
+++ b/crates/horizon-client/src/mobs/animal_brain.rs
@@ -625,8 +625,7 @@ fn targetable(m: &mut Mob, w: &MobWorld, who: Who) -> bool {
             // TargetingConditions.forNonCombat(): in range (scaled by the
             // player's visibility, at least 2) and in sight.
             let Some(p) = &w.player else { return false };
-            let visibility = if p.sneaking { 0.8 } else { 1.0 };
-            let r = (range * visibility).max(2.0);
+            let r = (range * p.visibility_percent()).max(2.0);
             p.alive && !p.spectator && m.distance_sqr(p.position) <= r * r && m.sees(w, who)
         }
         Who::Mob(id) => {
diff --git a/crates/horizon-client/src/mobs/aquatic.rs b/crates/horizon-client/src/mobs/aquatic.rs
index 3f86d8edc..59a73c605 100644
--- a/crates/horizon-client/src/mobs/aquatic.rs
+++ b/crates/horizon-client/src/mobs/aquatic.rs
@@ -24,6 +24,58 @@ const Z_BODY_ROT: usize = 3;
 const TENTACLE_SPEED: usize = 4;
 const ROTATE_SPEED: usize = 5;
 
+/// `Squid.spawnInk`: the squirt sound and 30 ink particles shot from under
+/// the squid, turned by its body rotation.
+pub fn spawn_ink(m: &mut Mob) {
+    let sound = if m.species() == Species::GlowSquid {
+        "entity.glow_squid.squirt"
+    } else {
+        "entity.squid.squirt"
+    };
+    let kind = if m.species() == Species::GlowSquid {
+        "glow_squid_ink"
+    } else {
+        "squid_ink"
+    };
+    // makeSound draws the voice pitch even for a silent squid.
+    let pitch = m.voice_pitch();
+    if !m.silent {
+        let at = [m.position.x, m.position.y, m.position.z];
+        m.outbox.push(MobEvent::Sound(
+            sound,
+            at,
+            super::ai::sound_volume(m),
+            pitch,
+        ));
+    }
+    // rotateVector: xRot(xBodyRotO), then yRot(-yBodyRotO).
+    let to_radians = (std::f64::consts::PI / 180.0) as f32;
+    let (x_rot, y_rot) = (
+        m.anim.vo[X_BODY_ROT] * to_radians,
+        -m.previous_body_yaw * to_radians,
+    );
+    let rotate = |v: Vec3| v.rotate_x(x_rot).rotate_y(y_rot);
+    let pos = rotate(Vec3::new(0.0, -1.0, 0.0)).add_vector(m.position);
+    let offset_scale: f32 = if m.is_baby() { 0.1 } else { 0.3 };
+    for _ in 0..30 {
+        let x = f64::from(m.random.next_float()) * 0.6 - 0.3;
+        let z = f64::from(m.random.next_float()) * 0.6 - 0.3;
+        let dir = rotate(Vec3::new(x, -1.0, z));
+        let d = dir.scale(f64::from(offset_scale + m.random.next_float() * 2.0));
+        // ServerLevel.sendParticles with a count of 0 and speed 0.1: one
+        // particle moving at the float offset times the float speed.
+        let speed = f64::from(0.1f32);
+        m.outbox.push(MobEvent::ParticleAt {
+            kind,
+            at: [pos.x, pos.y + 0.5, pos.z],
+            velocity: [
+                speed * f64::from(d.x as f32),
+                speed * f64::from(d.y as f32),
+                speed * f64::from(d.z as f32),
+            ],
+        });
+    }
+}
 pub fn register(m: &mut Mob) {
     use Species as S;
     match m.species() {
@@ -36,6 +88,7 @@ pub fn register(m: &mut Mob) {
             m.anim.v[TENTACLE_SPEED] = speed;
         }
         S::Axolotl => {
+            m.air = super::axolotl::MAX_AIR;
             // Native controller scaling is essential: the base speed attribute is 1.0.
             m.ai.mov.kind = MoveKind::SmoothSwimming {
                 max_turn_x: 85.0,
@@ -206,7 +259,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         }
         S::Dolphin => {
             // Dolphin.tick: moisture out of water, hop on land.
-            if m.fluids.in_water || w.raining {
+            if m.fluids.in_water || super::ai::in_rain(m, w) {
                 m.extra.counter = 2400;
             } else {
                 m.extra.counter -= 1;
diff --git a/crates/horizon-client/src/mobs/axolotl.rs b/crates/horizon-client/src/mobs/axolotl.rs
index 55f15717c..2815418e3 100644
--- a/crates/horizon-client/src/mobs/axolotl.rs
+++ b/crates/horizon-client/src/mobs/axolotl.rs
@@ -3,6 +3,8 @@ use super::{Mob, MobEvent, MobWorld, Species, Who, animal_brain, keyframes::Anim
 use horizon_core::random::RandomSource;
 pub const PLAY_DEAD_TICKS: i32 = 200;
 pub const HUNTING_COOLDOWN: i64 = 2400;
+/// `Axolotl.getMaxAirSupply`.
+pub const MAX_AIR: i32 = 6000;
 
 /// AxolotlAttackablesSensor: always-hostile targets bypass the hunting cooldown.
 pub fn prey_eligible(
diff --git a/crates/horizon-client/src/mobs/bee.rs b/crates/horizon-client/src/mobs/bee.rs
index 27d8e7c84..cecaff589 100644
--- a/crates/horizon-client/src/mobs/bee.rs
+++ b/crates/horizon-client/src/mobs/bee.rs
@@ -323,12 +323,19 @@ pub fn sting(m: &mut Mob, who: Who, cx: &mut Cx) {
     match who {
         Who::Player => {
             cx.events.push(MobEvent::AttackPlayer(amount, from));
-            let seconds = if cx.w.difficulty.hard { 18 } else { 10 };
-            cx.events.push(MobEvent::EffectPlayer {
-                effect: "minecraft:poison",
-                ticks: seconds * 20,
-                amplifier: 0,
-            });
+            // Poison only on normal (10 s) and hard (18 s).
+            let seconds = match cx.w.difficulty.id {
+                2 => 10,
+                3 => 18,
+                _ => 0,
+            };
+            if seconds > 0 {
+                cx.events.push(MobEvent::EffectPlayer {
+                    effect: "minecraft:poison",
+                    ticks: seconds * 20,
+                    amplifier: 0,
+                });
+            }
         }
         Who::Mob(id) => cx.events.push(MobEvent::AttackMob {
             target: id,
@@ -421,10 +428,10 @@ pub fn drop_off_nectar(m: &mut Mob) {
     set_has_nectar(m, false);
     st(m).crops_grown = 0;
 }
-/// `Bee.setStayOutOfHiveCountdown`, which in 26.3 only resets the time
-/// without nectar.
+/// `Bee.setStayOutOfHiveCountdown`: the bee will not enter a hive for 400
+/// ticks (the hive passes that when a sedated hive lets its bees out).
 pub fn set_stay_out_of_hive_countdown(m: &mut Mob) {
-    st(m).ticks_without_nectar = 0;
+    st(m).stay_out_of_hive = 400;
 }
 fn drop_hive(m: &mut Mob) {
     let b = st(m);
diff --git a/crates/horizon-client/src/mobs/body_anim.rs b/crates/horizon-client/src/mobs/body_anim.rs
index 4411d347b..360e1447f 100644
--- a/crates/horizon-client/src/mobs/body_anim.rs
+++ b/crates/horizon-client/src/mobs/body_anim.rs
@@ -959,7 +959,7 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool {
     let st = &m.anim.states;
     match m.species() {
         Species::Goat => goat(p, s, &Goat::from_mob(m)),
-        Species::PolarBear => polar_bear(p, s, 0.0),
+        Species::PolarBear => polar_bear(p, s, super::polar_bear::standing_scale(m, s.partial)),
         Species::Panda => panda(p, s, &Panda::default()),
         Species::Llama | Species::TraderLlama => {
             llama(p, s, m.extra.chested && !s.baby);
@@ -969,8 +969,8 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool {
             s,
             &Turtle {
                 on_land: !m.fluids.in_water && m.on_ground,
-                laying_egg: false,
-                has_egg: false,
+                laying_egg: m.extra.flag2,
+                has_egg: m.extra.flag,
             },
         ),
         Species::Strider => strider(p, s, m.rider.is_some()),
@@ -980,9 +980,10 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool {
         Species::Parrot => {
             let flap = m.anim.flap_o + (m.anim.flap - m.anim.flap_o) * s.partial;
             let speed = m.anim.flap_speed_o + (m.anim.flap_speed - m.anim.flap_speed_o) * s.partial;
+            // `Parrot.isFlying` is `!onGround`, in water too.
             let pose = if m.extra.sitting {
                 ParrotPose::Sitting
-            } else if !m.on_ground && !m.fluids.in_water {
+            } else if !m.on_ground {
                 ParrotPose::Flying
             } else {
                 ParrotPose::Standing
diff --git a/crates/horizon-client/src/mobs/breeze.rs b/crates/horizon-client/src/mobs/breeze.rs
index 5d78fa8ab..dee48f3d0 100644
--- a/crates/horizon-client/src/mobs/breeze.rs
+++ b/crates/horizon-client/src/mobs/breeze.rs
@@ -31,6 +31,28 @@ pub fn pose(m: &Mob) -> u8 {
 pub(super) fn set_pose(m: &mut Mob, pose: u8) {
     m.extra.variant3 = pose;
 }
+/// `Pose.id` of the pose (`sync::pose_id`), and its inverse.
+pub fn pose_id(m: &Mob) -> u8 {
+    match pose(m) {
+        SHOOTING => 16,
+        INHALING => 17,
+        LONG_JUMPING => 6,
+        SLIDING => 15,
+        _ => 0,
+    }
+}
+pub(super) fn set_pose_id(m: &mut Mob, id: u8) {
+    set_pose(
+        m,
+        match id {
+            16 => SHOOTING,
+            17 => INHALING,
+            6 => LONG_JUMPING,
+            15 => SLIDING,
+            _ => STANDING,
+        },
+    );
+}
 /// `Breeze.getFiringYPosition`.
 pub fn firing_y(m: &Mob) -> f64 {
     m.position.y + f64::from(m.height()) / 2.0 + f64::from(0.3_f32)
diff --git a/crates/horizon-client/src/mobs/camel.rs b/crates/horizon-client/src/mobs/camel.rs
index 21ebe9e16..427b4c5ca 100644
--- a/crates/horizon-client/src/mobs/camel.rs
+++ b/crates/horizon-client/src/mobs/camel.rs
@@ -24,12 +24,13 @@ pub fn register(m: &mut Mob) {
     m.extra.tame = true;
     let tempt = m.kind.tempt.clone();
     let g = &mut m.ai.goals;
+    // CamelAi speed modifiers (times the 0.09 movement speed attribute).
     g.add(0, Float);
-    g.add(1, CamelPanic(Panic::new(4.0 * 0.25)));
+    g.add(1, CamelPanic(Panic::new(4.0)));
     g.add(2, Breed::new(1.0));
-    g.add(3, Tempt::new(2.5 * 0.25, tempt, false));
-    g.add(4, FollowParent::new(2.5 * 0.25));
-    g.add(5, Stroll::new(2.0 * 0.25));
+    g.add(3, Tempt::new(2.5, tempt, false));
+    g.add(4, FollowParent::new(2.5));
+    g.add(5, Stroll::new(2.0));
     g.add(5, RandomSitting);
     g.add(6, LookAtPlayer::new(6.0));
     g.add(7, RandomLookAround::default());
@@ -45,6 +46,25 @@ pub fn sitting(m: &Mob) -> bool {
 fn in_transition(m: &Mob) -> bool {
     pose_time(m) < if sitting(m) { SIT_DOWN } else { STAND_UP }
 }
+/// `Camel.getPoseTime` of a client mob from the `LAST_POSE_CHANGE_TICK` it
+/// was sent and the client's game time, and whether that value says it sits.
+fn client_pose(m: &Mob, game_time: i64) -> (i64, bool) {
+    let tick = m.extra.pose_change_tick;
+    (game_time - tick.abs(), tick < 0)
+}
+/// The camel's `LAST_POSE_CHANGE_TICK` as the server sends it: in game time
+/// (a mob counts its own age), negative while sitting.
+pub fn synced_pose_tick(m: &Mob, game_time: i64) -> i64 {
+    let tick = (game_time - pose_time(m)).max(0);
+    if sitting(m) { -tick.max(1) } else { tick }
+}
+/// `Entity.onSyncedDataUpdated` for the pose tick of a client mob: its sign
+/// is whether it sits. `client_tick` keeps `egg_time` (in the mob's age, for
+/// `sitting` and `refuse_to_move`) with it.
+pub fn set_synced_pose_tick(m: &mut Mob, tick: i64) {
+    m.extra.pose_change_tick = tick;
+    m.extra.egg_time = if tick < 0 { -1 } else { 0 };
+}
 /// `Camel.refuseToMove`: sitting or getting up or down.
 pub fn refuse_to_move(m: &Mob) -> bool {
     sitting(m) || in_transition(m)
@@ -166,7 +186,29 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
         m.ai.zza = 0.0;
         m.ai.nav.stop();
     }
-    // setupAnimationStates.
+    animation_states(m, pose_time(m), sitting(m));
+}
+/// `Camel.tick` on a client that is not the server: the dash cooldown, which
+/// the dash flag starts, and the keyframe states from the synced pose tick.
+pub fn client_tick(m: &mut Mob, game_time: i64) {
+    if m.extra.anim_ticks > 0 {
+        m.extra.anim_ticks -= 1;
+    }
+    let (pose_time, sitting) = client_pose(m, game_time);
+    let since = (i64::from(m.age) - pose_time).max(0) as i32;
+    m.extra.egg_time = if sitting { -since.max(1) } else { since };
+    animation_states(m, pose_time, sitting);
+}
+/// `Camel.onSyncedDataUpdated(DASH)`: a dash starts the cooldown unless it
+/// runs. Not on the first tick.
+pub fn set_dashing(m: &mut Mob, dashing: bool) {
+    if m.age > 0 && m.extra.anim_ticks == 0 {
+        m.extra.anim_ticks = DASH_COOLDOWN;
+    }
+    m.extra.flag2 = dashing;
+}
+/// `Camel.setupAnimationStates` for a pose time and whether it sits.
+fn animation_states(m: &mut Mob, pose_time: i64, sitting: bool) {
     let age = m.age as f32;
     if m.extra.ints[0] <= 0 {
         m.extra.ints[0] = m.random.next_int_bound(40).unwrap_or(0) + 80;
@@ -175,9 +217,9 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
         m.extra.ints[0] -= 1;
     }
     // isCamelVisuallySitting: (poseTime < 0) != sitting.
-    let visually_sitting = (pose_time(m) < 0) != sitting(m);
-    let sitting_down = sitting(m) && pose_time(m) < SIT_DOWN && pose_time(m) >= 0;
-    let transition = in_transition(m) && pose_time(m) >= 0;
+    let visually_sitting = (pose_time < 0) != sitting;
+    let sitting_down = sitting && (0..SIT_DOWN).contains(&pose_time);
+    let transition = (0..if sitting { SIT_DOWN } else { STAND_UP }).contains(&pose_time);
     let dashing = m.extra.flag2;
     let st = &mut m.anim.states;
     if visually_sitting {
diff --git a/crates/horizon-client/src/mobs/control.rs b/crates/horizon-client/src/mobs/control.rs
index 3df557362..e6874ea0b 100644
--- a/crates/horizon-client/src/mobs/control.rs
+++ b/crates/horizon-client/src/mobs/control.rs
@@ -1,12 +1,12 @@
 //! Mob controls: `MoveControl` (with the flying and smooth-swimming
 //! variants), `LookControl`, `JumpControl` and `BodyRotationControl`.
-use super::{Mob, MobWorld, living::wrap};
+use super::{Mob, MobWorld, Species, living::wrap};
 use horizon_core::geometry::trig;
 
 /// `2.5000003E-7F` widened: the squared distance controls treat as arrived.
 const ARRIVED: f64 = 2.500_000_3e-7_f32 as f64;
 /// `1.0E-5F` widened.
-const EPSILON: f64 = 1.0e-5_f32 as f64;
+pub(super) const EPSILON: f64 = 1.0e-5_f32 as f64;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum Operation {
@@ -90,6 +90,9 @@ pub enum LookKind {
     Fixed,
     /// `HappyGhast.HappyGhastLookControl`.
     HappyGhast,
+    /// `Shulker.ShulkerLookControl`: the yaw turns in the attach face's
+    /// plane and the head is never clamped to the body.
+    Shulker,
 }
 #[derive(Clone, Debug, Default)]
 pub struct LookControl {
@@ -113,8 +116,16 @@ pub struct BodyRotation {
     last_stable_head: f32,
 }
 impl Mob {
+    /// `Mob.getMaxHeadXRot`, with `Wolf`'s 20 degrees while sitting.
+    pub fn max_head_x_rot(&self) -> f32 {
+        if self.species() == Species::Wolf && self.extra.sitting {
+            20.0
+        } else {
+            self.kind.max_head_x_rot
+        }
+    }
     pub fn look_at(&mut self, at: [f64; 3]) {
-        let (y, x) = (self.kind.head_rot_speed, self.kind.max_head_x_rot);
+        let (y, x) = (self.kind.head_rot_speed, self.max_head_x_rot());
         self.ai.look.set_look_at(at, y, x);
     }
     pub fn look_at_speed(&mut self, at: [f64; 3], y_speed: f32, x_max: f32) {
@@ -135,6 +146,9 @@ impl Mob {
         if self.species() == super::Species::Rabbit {
             return super::rabbit::move_control(self, w);
         }
+        if self.species() == super::Species::Turtle {
+            return super::turtle::move_control(self);
+        }
         let attr_speed = self.movement_speed();
         match self.ai.mov.kind {
             MoveKind::Custom => super::ai::custom_move_control(self, w, events),
@@ -345,6 +359,20 @@ impl Mob {
                     self.body_yaw += 4.0;
                 }
             }
+            LookKind::Shulker => {
+                // ShulkerLookControl: resetXRotOnTick, getXRotD 0, and the
+                // yaw worked out in the attach face's plane (getYRotD).
+                self.head_pitch = 0.0;
+                if look.cooldown > 0 {
+                    self.ai.look.cooldown -= 1;
+                    if let Some(y) = super::shulker::look_yaw(self, look.wanted) {
+                        self.head_yaw = rotate_towards(self.head_yaw, y, look.y_max_rot_speed);
+                    }
+                } else {
+                    self.head_yaw = rotate_towards(self.head_yaw, self.body_yaw, 10.0);
+                }
+                // clampHeadRotationToBody does nothing for a shulker.
+            }
             LookKind::Default | LookKind::Fixed => {
                 if look.kind == LookKind::Default {
                     self.head_pitch = 0.0;
@@ -389,6 +417,13 @@ impl Mob {
     }
     /// BodyRotationControl.clientTick (Mob.tickHeadTurn).
     pub fn body_rotation_tick(&mut self) {
+        // Shulker.ShulkerBodyRotationControl.clientTick is empty: the body
+        // stays at 0 (recreateFromPacket), only the head turns.
+        if self.species() == super::Species::Shulker {
+            self.body_yaw = 0.0;
+            self.previous_body_yaw = 0.0;
+            return;
+        }
         let dx = self.position.x - self.previous.x;
         let dz = self.position.z - self.previous.z;
         let max = self.kind.max_head_y_rot;
diff --git a/crates/horizon-client/src/mobs/doors.rs b/crates/horizon-client/src/mobs/doors.rs
new file mode 100644
index 000000000..a55ab9863
--- /dev/null
+++ b/crates/horizon-client/src/mobs/doors.rs
@@ -0,0 +1,252 @@
+//! Doors a mob gets through on its own: `DoorInteractGoal` with its two
+//! users, `BreakDoorGoal` (zombies that can break doors, vindicators in a
+//! raid) and `OpenDoorGoal` (`AbstractIllager.RaiderOpenDoorGoal`).
+use super::{
+    Mob, MobEvent, MobWorld, Species,
+    goals::{Cx, Goal, MOVE, goal_clone, reduced},
+    nav::NavKind,
+    raider,
+};
+use horizon_core::{geometry::Vec3, random::RandomSource};
+
+/// `DefaultDoorBreakTime`: `BreakDoorGoal.getDoorBreakTime` is
+/// `max(240, doorBreakTime)`, and the vindicator's 6 is below it.
+const DOOR_BREAK_TIME: i32 = 240;
+
+/// `GoalUtils.hasGroundPathNavigation`: ground, wall-climbing and
+/// amphibious navigations walk.
+pub fn can_navigate_ground(m: &Mob) -> bool {
+    matches!(
+        m.ai.nav.kind,
+        NavKind::Ground | NavKind::WallClimber | NavKind::Amphibious
+    )
+}
+/// `Zombie.setCanBreakDoors`: only a mob that walks can break doors, and
+/// then its navigation opens them.
+pub fn set_can_break_doors(m: &mut Mob, can_break: bool) {
+    let can_break = can_break && can_navigate_ground(m);
+    m.extra.can_break_doors = can_break;
+    m.ai.nav.can_open_doors = can_break;
+}
+/// The species that extend `Zombie` (`CanBreakDoors` is theirs to save).
+pub fn is_zombie(s: Species) -> bool {
+    matches!(
+        s,
+        Species::Zombie
+            | Species::Husk
+            | Species::Drowned
+            | Species::ZombieVillager
+            | Species::ZombifiedPiglin
+    )
+}
+/// `DoorBlock.isWoodenDoor`: a door a hand opens, which is any but iron.
+fn wooden_door(w: &MobWorld, p: [i32; 3]) -> bool {
+    let name = w.block_name(p[0], p[1], p[2]);
+    name.ends_with("_door") && name != "minecraft:iron_door"
+}
+/// `DoorInteractGoal`'s door: where it is and whether one is there.
+#[derive(Clone, Debug, Default)]
+struct Interact {
+    door: [i32; 3],
+    has_door: bool,
+}
+impl Interact {
+    /// `DoorInteractGoal.canUse`: the mob bumped into something and a
+    /// wooden door is on its path within 1.5 blocks, or at its own head.
+    fn can_use(&mut self, m: &Mob, w: &MobWorld) -> bool {
+        if !can_navigate_ground(m) || !m.horizontal_collision {
+            return false;
+        }
+        let Some(path) = m.ai.nav.path.as_ref().filter(|p| !p.is_done()) else {
+            return false;
+        };
+        for node in path
+            .nodes
+            .iter()
+            .take((path.next + 2).min(path.nodes.len()))
+        {
+            self.door = [node.x, node.y + 1, node.z];
+            let dx = m.position.x - f64::from(node.x);
+            let dz = m.position.z - f64::from(node.z);
+            if dx * dx + dz * dz <= 2.25 {
+                self.has_door = wooden_door(w, self.door);
+                if self.has_door {
+                    return true;
+                }
+            }
+        }
+        let at = m.position;
+        self.door = [
+            at.x.floor() as i32,
+            at.y.floor() as i32 + 1,
+            at.z.floor() as i32,
+        ];
+        self.has_door = wooden_door(w, self.door);
+        self.has_door
+    }
+    /// `DoorInteractGoal.isOpen`: the door is still there and open.
+    fn is_open(&mut self, w: &MobWorld) -> bool {
+        if !self.has_door {
+            return false;
+        }
+        let d = self.door;
+        if !w.block_name(d[0], d[1], d[2]).ends_with("_door") {
+            self.has_door = false;
+            return false;
+        }
+        w.prop(d[0], d[1], d[2], "open") == Some("true")
+    }
+    /// `DoorInteractGoal.setOpen`.
+    fn set_open(&self, cx: &mut Cx, open: bool) {
+        let d = self.door;
+        if self.has_door && cx.w.block_name(d[0], d[1], d[2]).ends_with("_door") {
+            cx.events.push(MobEvent::SetDoorOpen { pos: d, open });
+        }
+    }
+}
+/// `BlockPos.closerToCenterThan`.
+fn closer_to_center(p: [i32; 3], at: Vec3, distance: f64) -> bool {
+    Vec3::new(
+        f64::from(p[0]) + 0.5,
+        f64::from(p[1]) + 0.5,
+        f64::from(p[2]) + 0.5,
+    )
+    .distance_squared(at)
+        < distance * distance
+}
+
+/// `BreakDoorGoal`: crack the door in the way for 240 ticks, then remove it.
+/// A zombie does it on hard only; `Vindicator.VindicatorBreakDoorGoal` on
+/// normal and hard, in a raid, and holds the mob's movement.
+#[derive(Clone, Debug)]
+pub struct BreakDoor {
+    interact: Interact,
+    vindicator: bool,
+    break_time: i32,
+    last_break_progress: i32,
+}
+impl BreakDoor {
+    /// `Zombie.breakDoorGoal`, added when the zombie can break doors.
+    pub fn zombie() -> Self {
+        Self::new(false)
+    }
+    /// `Vindicator.VindicatorBreakDoorGoal`.
+    pub fn vindicator() -> Self {
+        Self::new(true)
+    }
+    fn new(vindicator: bool) -> Self {
+        Self {
+            interact: Interact::default(),
+            vindicator,
+            break_time: 0,
+            last_break_progress: -1,
+        }
+    }
+    /// `DOOR_BREAKING_PREDICATE`.
+    fn valid_difficulty(&self, w: &MobWorld) -> bool {
+        if self.vindicator {
+            w.difficulty.normal || w.difficulty.hard
+        } else {
+            w.difficulty.hard
+        }
+    }
+    /// `BreakDoorGoal.canUse` after `DoorInteractGoal.canUse`.
+    fn can_break(&mut self, m: &Mob, w: &MobWorld) -> bool {
+        self.interact.can_use(m, w)
+            && w.mob_griefing
+            && self.valid_difficulty(w)
+            && !self.interact.is_open(w)
+    }
+}
+impl Goal for BreakDoor {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        if self.vindicator { MOVE } else { 0 }
+    }
+    fn every_tick(&self) -> bool {
+        true
+    }
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        if self.vindicator {
+            return raider::has_active_raid(m)
+                && m.random.next_int_bound(reduced(10)).unwrap_or(1) == 0
+                && self.can_break(m, cx.w);
+        }
+        m.extra.can_break_doors && self.can_break(m, cx.w)
+    }
+    fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        (!self.vindicator || raider::has_active_raid(m))
+            && self.break_time <= DOOR_BREAK_TIME
+            && !self.interact.is_open(cx.w)
+            && closer_to_center(self.interact.door, m.position, 2.0)
+            && self.valid_difficulty(cx.w)
+    }
+    fn start(&mut self, m: &mut Mob, _cx: &mut Cx) {
+        self.break_time = 0;
+        if self.vindicator {
+            m.ai.no_action_time = 0;
+        }
+    }
+    fn stop(&mut self, m: &mut Mob, cx: &mut Cx) {
+        cx.events.push(MobEvent::DestroyProgress {
+            mob: m.id,
+            pos: self.interact.door,
+            progress: -1,
+        });
+    }
+    fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
+        let door = self.interact.door;
+        if m.random.next_int_bound(20).unwrap_or(1) == 0 {
+            cx.events.push(MobEvent::LevelEvent {
+                id: 1019,
+                pos: door,
+                data: 0,
+            });
+            if !m.ai.swinging {
+                m.swing();
+            }
+        }
+        self.break_time += 1;
+        let progress = (self.break_time as f32 / DOOR_BREAK_TIME as f32 * 10.0) as i32;
+        if progress != self.last_break_progress {
+            cx.events.push(MobEvent::DestroyProgress {
+                mob: m.id,
+                pos: door,
+                progress,
+            });
+            self.last_break_progress = progress;
+        }
+        if self.break_time == DOOR_BREAK_TIME && self.valid_difficulty(cx.w) {
+            cx.events.push(MobEvent::BreakDoor { pos: door });
+        }
+    }
+}
+
+/// `AbstractIllager.RaiderOpenDoorGoal` (`OpenDoorGoal` that does not wait
+/// to close): open the door in the way during a raid. It never continues, so
+/// it closes the door again as soon as it stops.
+#[derive(Clone, Debug, Default)]
+pub struct RaiderOpenDoor {
+    interact: Interact,
+}
+impl Goal for RaiderOpenDoor {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        0
+    }
+    fn every_tick(&self) -> bool {
+        true
+    }
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        self.interact.can_use(m, cx.w) && raider::has_active_raid(m)
+    }
+    fn can_continue(&mut self, _m: &mut Mob, _cx: &mut Cx) -> bool {
+        false
+    }
+    fn start(&mut self, _m: &mut Mob, cx: &mut Cx) {
+        self.interact.set_open(cx, true);
+    }
+    fn stop(&mut self, _m: &mut Mob, cx: &mut Cx) {
+        self.interact.set_open(cx, false);
+    }
+}
diff --git a/crates/horizon-client/src/mobs/drops.rs b/crates/horizon-client/src/mobs/drops.rs
index e5ccfd283..3168d8f1e 100644
--- a/crates/horizon-client/src/mobs/drops.rs
+++ b/crates/horizon-client/src/mobs/drops.rs
@@ -304,6 +304,7 @@ fn loot_stack(item: &str, count: i32) -> LootStack {
         map: false,
         exploration: None,
         ominous_amplifier: None,
+        stew_effects: Vec::new(),
     }
 }
 /// `Mob.dropChances.byEquipment(slot)`: the recorded chance, or the one the
@@ -350,6 +351,9 @@ pub fn loot_entity(m: &Mob, vehicle: Option<LootEntity>) -> LootEntity {
             .to_owned(),
         );
     }
+    if s == S::Chicken {
+        e.chicken_variant = super::finalize::variant_component(m).map(|(_, id)| id);
+    }
     e.powered = s == S::Creeper && m.extra.charged;
     e.equipment = SLOTS
         .iter()
@@ -399,6 +403,15 @@ pub fn die(m: &mut Mob, d: &Death, sequences: &mut RandomSequences) -> (Vec<Drop
         out.push(Drop::Item(stack));
         clear_slot(m, "mainhand");
     }
+    // Allay: what it carries (`ints[1]` of the held item) is its inventory.
+    let allay_load = (s == Species::Allay)
+        .then(|| {
+            m.extra
+                .main_hand
+                .clone()
+                .map(|item| (item, m.extra.ints[1]))
+        })
+        .flatten();
     let drops_loot = d.mob_drops && (is_monster(s) || !m.is_baby());
     if drops_loot {
         let table = format!(
@@ -455,6 +468,27 @@ pub fn die(m: &mut Mob, d: &Death, sequences: &mut RandomSequences) -> (Vec<Drop
             out.push(Drop::Item(loot_stack("minecraft:nether_star", 1)));
         }
     }
+    // Allay.dropEquipment: its inventory, then the main-hand item unless it
+    // prevents equipment drops.
+    if let Some((item, carried)) = allay_load {
+        if carried > 0 {
+            out.push(Drop::Item(loot_stack(&item, carried)));
+        }
+        if let Some(stack) = slot_item(m, "mainhand")
+            && !d.loot.prevents_equipment_drop(&stack)
+        {
+            out.push(Drop::Item(stack));
+            clear_slot(m, "mainhand");
+        }
+    }
+    // Piglin.dropCustomDeathLoot: everything in its inventory.
+    if s == Species::Piglin {
+        for stack in m.extra.inventory.drain(..) {
+            let mut item = loot_stack(&stack.item, stack.count as i32);
+            item.damage = stack.damage as i32;
+            out.push(Drop::Item(item));
+        }
+    }
     // dropEquipment: AbstractHorse's inventory, then a chested horse's chest.
     if equine::is_equine(s) {
         for stack in m.extra.items.iter().flatten() {
diff --git a/crates/horizon-client/src/mobs/enderman.rs b/crates/horizon-client/src/mobs/enderman.rs
index c5ed01680..17566fb65 100644
--- a/crates/horizon-client/src/mobs/enderman.rs
+++ b/crates/horizon-client/src/mobs/enderman.rs
@@ -184,15 +184,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
             }
         }
     }
-    if (m.fluids.in_water
-        || w.raining
-            && w.can_see_sky(
-                m.position.x.floor() as i32,
-                m.eye_y().floor() as i32,
-                m.position.z.floor() as i32,
-            ))
-        && m.alive()
-    {
+    if (m.fluids.in_water || super::ai::in_rain(m, w)) && m.alive() {
         // Hurt by water: teleport away.
         m.extra.counter2 = m.extra.counter2.max(1);
     }
@@ -331,8 +323,11 @@ impl Goal for TakeBlock {
     fn flags(&self) -> u8 {
         0
     }
-    fn can_use(&mut self, m: &mut Mob, _: &mut Cx) -> bool {
-        m.extra.carried.is_none() && m.random.next_int_bound(reduced(20)).unwrap_or(1) == 0
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        // EndermanTakeBlockGoal.canUse: needs mobGriefing, checked before the draw.
+        m.extra.carried.is_none()
+            && cx.w.mob_griefing
+            && m.random.next_int_bound(reduced(20)).unwrap_or(1) == 0
     }
     fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
         let x = (m.position.x - 2.0 + m.random.next_double() * 4.0).floor() as i32;
@@ -379,8 +374,11 @@ impl Goal for LeaveBlock {
     fn flags(&self) -> u8 {
         0
     }
-    fn can_use(&mut self, m: &mut Mob, _: &mut Cx) -> bool {
-        m.extra.carried.is_some() && m.random.next_int_bound(reduced(2000)).unwrap_or(1) == 0
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        // EndermanLeaveBlockGoal.canUse: needs mobGriefing, checked before the draw.
+        m.extra.carried.is_some()
+            && cx.w.mob_griefing
+            && m.random.next_int_bound(reduced(2000)).unwrap_or(1) == 0
     }
     fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
         let Some(carried) = m.extra.carried else {
diff --git a/crates/horizon-client/src/mobs/equine.rs b/crates/horizon-client/src/mobs/equine.rs
index 5bb5faf53..1155388fd 100644
--- a/crates/horizon-client/src/mobs/equine.rs
+++ b/crates/horizon-client/src/mobs/equine.rs
@@ -28,6 +28,8 @@ pub const MARKINGS: [&str; 5] = ["", "white", "whitefield", "whitedots", "blackd
 pub const EAT: usize = 0;
 pub const STAND: usize = 1;
 pub const MOUTH: usize = 2;
+/// `AbstractHorse.tailCounter`: client-side, it only drives the model.
+pub const TAIL: usize = 3;
 
 /// What a rider asks of its mount this tick.
 #[derive(Clone, Copy, Debug, Default)]
@@ -418,6 +420,20 @@ pub fn ridden_step(m: &mut Mob) {
         }
     }
 }
+/// `AbstractHorse.aiStep`'s `moveTail` (one in 200 ticks) and the counter's
+/// step in `tick` (it runs to 8, then stops). A client runs it on its own
+/// random, as vanilla's client-side `aiStep` does.
+pub fn tail_tick(m: &mut Mob) {
+    if m.random.next_int_bound(200).unwrap_or(1) == 0 {
+        m.anim.v[TAIL] = 1.0;
+    }
+    if m.anim.v[TAIL] > 0.0 {
+        m.anim.v[TAIL] += 1.0;
+        if m.anim.v[TAIL] > 8.0 {
+            m.anim.v[TAIL] = 0.0;
+        }
+    }
+}
 /// `AbstractHorse.aiStep` and `tick`: healing, grazing, the rear and the
 /// eating/standing/mouth animations.
 pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
@@ -603,7 +619,15 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses) {
         t[1] += speed * age;
         t[2] += speed * 2.0 * age;
     }
-    p.yrot("tail", 0.0);
+    // animateTail: the tail swings while the counter runs.
+    p.yrot(
+        "tail",
+        if m.anim.v[TAIL] > 0.0 {
+            (s.age * 0.7).mcos()
+        } else {
+            0.0
+        },
+    );
     if baby && donkey {
         // BabyDonkeyModel overrides the state's pitch with -30 degrees and
         // sets the head parts again.
diff --git a/crates/horizon-client/src/mobs/farm.rs b/crates/horizon-client/src/mobs/farm.rs
index 83d5ac1f5..87951b0e2 100644
--- a/crates/horizon-client/src/mobs/farm.rs
+++ b/crates/horizon-client/src/mobs/farm.rs
@@ -80,6 +80,7 @@ pub fn chicken_ai_step(m: &mut Mob, _w: &MobWorld, events: &mut Vec<MobEvent>) {
             let at = [m.position.x, m.position.y, m.position.z];
             events.push(MobEvent::Sound("entity.chicken.egg", at, 1.0, pitch));
             events.push(MobEvent::GiftLoot {
+                mob: m.id,
                 table: "minecraft:gameplay/chicken_lay",
                 at,
             });
diff --git a/crates/horizon-client/src/mobs/finalize.rs b/crates/horizon-client/src/mobs/finalize.rs
index 4eeed885b..ccf4564ca 100644
--- a/crates/horizon-client/src/mobs/finalize.rs
+++ b/crates/horizon-client/src/mobs/finalize.rs
@@ -590,6 +590,14 @@ pub fn has_modifier(m: &Mob, a: Attr, id: &str) -> bool {
         .as_ref()
         .is_some_and(|s| s.modifiers.iter().any(|x| x.attr == a && x.id == id))
 }
+/// The amount of a permanent modifier, if the mob has it.
+pub fn modifier_amount(m: &Mob, a: Attr, id: &str) -> Option<f64> {
+    m.extra
+        .attributes
+        .as_ref()
+        .and_then(|s| s.modifiers.iter().find(|x| x.attr == a && x.id == id))
+        .map(|x| x.amount)
+}
 /// `addOrReplacePermanentModifier`.
 pub fn add_modifier(m: &mut Mob, a: Attr, id: &'static str, amount: f64, op: Op) {
     let s = m.extra.attributes.get_or_insert_with(Box::default);
@@ -605,6 +613,59 @@ pub fn add_modifier(m: &mut Mob, a: Attr, id: &'static str, amount: f64, op: Op)
     }
     refresh(m, a);
 }
+/// `Zombie.handleAttributes`, from the zombie's own random.
+pub fn zombie_attributes(m: &mut Mob, special: f32, reason: Reason) {
+    let r = &mut m.random;
+    let reinforcements = if m.kind.species == Species::ZombifiedPiglin {
+        0.0
+    } else {
+        r.next_double() * f64::from(0.1f32)
+    };
+    let knockback = r.next_double() * f64::from(0.05f32);
+    let follow = r.next_double() * 1.5 * f64::from(special);
+    let leader = r.next_float() < special * 0.05;
+    let leader_rolls = leader.then(|| (r.next_double() * 0.25 + 0.5, r.next_double() * 3.0 + 1.0));
+    set_base(m, Attr::SpawnReinforcements, reinforcements);
+    add_modifier(
+        m,
+        Attr::KnockbackResistance,
+        "minecraft:random_spawn_bonus",
+        knockback,
+        Op::AddValue,
+    );
+    if follow > 1.0 {
+        add_modifier(
+            m,
+            Attr::FollowRange,
+            "minecraft:zombie_random_spawn_bonus",
+            follow,
+            Op::AddMultipliedTotal,
+        );
+    }
+    if let Some((reinforce, health)) = leader_rolls {
+        add_modifier(
+            m,
+            Attr::SpawnReinforcements,
+            "minecraft:leader_zombie_bonus",
+            reinforce,
+            Op::AddValue,
+        );
+        add_modifier(
+            m,
+            Attr::MaxHealth,
+            "minecraft:leader_zombie_bonus",
+            health,
+            Op::AddMultipliedTotal,
+        );
+        if !matches!(
+            reason,
+            Reason::Conversion | Reason::Load | Reason::DimensionTravel
+        ) {
+            m.health = max_health(m);
+        }
+        super::doors::set_can_break_doors(m, true);
+    }
+}
 pub fn max_health(m: &Mob) -> f32 {
     value(m, Attr::MaxHealth) as f32
 }
@@ -829,6 +890,14 @@ pub fn set_item(m: &mut Mob, slot: usize, id: &str) {
     }
     gear::set(m, gear_slot(slot), Vec::new());
 }
+/// The enchantments on what `m` has in `slot`.
+pub fn slot_enchantments(m: &Mob, slot: usize) -> gear::Levels {
+    gear::gear(m).map_or_else(Vec::new, |g| g.slots[gear_slot(slot)].clone())
+}
+/// Replace the enchantments of what `m` has in `slot` (after `set_item`).
+pub fn set_slot_enchantments(m: &mut Mob, slot: usize, levels: gear::Levels) {
+    gear::set(m, gear_slot(slot), levels);
+}
 /// `Mob.setDropChance`.
 pub fn set_drop_chance(m: &mut Mob, slot: usize, chance: f32) {
     let c = m
@@ -1144,70 +1213,17 @@ impl<L: FinalizeLevel + ?Sized, R: RandomSource> Ctx<'_, L, R> {
                     }
                 }
             }
-            m.extra.can_break_doors = self.float() < special * 0.1;
+            let can_break_doors = self.float() < special * 0.1;
+            super::doors::set_can_break_doors(m, can_break_doors);
             if reason != Reason::Conversion {
                 self.populate(m);
                 self.enchant(m);
             }
         }
         self.halloween(m);
-        self.zombie_attributes(m, special, reason);
+        zombie_attributes(m, special, reason);
         g
     }
-    /// `Zombie.handleAttributes`, from the zombie's own random.
-    fn zombie_attributes(&mut self, m: &mut Mob, special: f32, reason: Reason) {
-        let r = &mut m.random;
-        let reinforcements = if m.kind.species == Species::ZombifiedPiglin {
-            0.0
-        } else {
-            r.next_double() * f64::from(0.1f32)
-        };
-        let knockback = r.next_double() * f64::from(0.05f32);
-        let follow = r.next_double() * 1.5 * f64::from(special);
-        let leader = r.next_float() < special * 0.05;
-        let leader_rolls =
-            leader.then(|| (r.next_double() * 0.25 + 0.5, r.next_double() * 3.0 + 1.0));
-        set_base(m, Attr::SpawnReinforcements, reinforcements);
-        add_modifier(
-            m,
-            Attr::KnockbackResistance,
-            "minecraft:random_spawn_bonus",
-            knockback,
-            Op::AddValue,
-        );
-        if follow > 1.0 {
-            add_modifier(
-                m,
-                Attr::FollowRange,
-                "minecraft:zombie_random_spawn_bonus",
-                follow,
-                Op::AddMultipliedTotal,
-            );
-        }
-        if let Some((reinforce, health)) = leader_rolls {
-            add_modifier(
-                m,
-                Attr::SpawnReinforcements,
-                "minecraft:leader_zombie_bonus",
-                reinforce,
-                Op::AddValue,
-            );
-            add_modifier(
-                m,
-                Attr::MaxHealth,
-                "minecraft:leader_zombie_bonus",
-                health,
-                Op::AddMultipliedTotal,
-            );
-            if !matches!(
-                reason,
-                Reason::Conversion | Reason::Load | Reason::DimensionTravel
-            ) {
-                m.health = max_health(m);
-            }
-            m.extra.can_break_doors = true;
-        }
-    }
     fn husk(&mut self, m: &mut Mob, g: Option<Group>, reason: Reason) -> Option<Group> {
         let mut g = self.zombie(m, g, reason);
         if reason != Reason::Conversion {
@@ -1492,7 +1508,7 @@ impl<L: FinalizeLevel + ?Sized, R: RandomSource> Ctx<'_, L, R> {
     }
     fn sound(&mut self, m: &mut Mob, registry: fn(&SpawnRegistries) -> &VariantRegistry) {
         let r = registry(self.data.registries);
-        m.extra.sound_variant = r.random(self.random) as u8;
+        m.extra.sound_variant = Some(r.random(self.random) as u8);
     }
 
     /// `finalizeSpawn` of the mob's class.
@@ -1998,6 +2014,17 @@ pub fn species_variant_component(s: Species, variant: u8) -> Option<(&'static st
     };
     Some((component, format!("minecraft:{}", variant_name(s, variant))))
 }
+/// The `*_sound_variant` registry of a species, in registry order.
+pub fn sound_variants(s: Species) -> &'static [&'static str] {
+    match s {
+        Species::Pig => &["big", "classic", "mini"],
+        Species::Cow => &["classic", "moody"],
+        Species::Chicken => &["classic", "picky"],
+        Species::Cat => &["classic", "royal"],
+        Species::Wolf => &["angry", "big", "classic", "cute", "grumpy", "puglin", "sad"],
+        _ => &[],
+    }
+}
 /// The registry name of the game's variant index.
 pub fn variant_name(s: Species, index: u8) -> &'static str {
     let i = index as usize;
diff --git a/crates/horizon-client/src/mobs/goals.rs b/crates/horizon-client/src/mobs/goals.rs
index 7f73e32c4..6704246de 100644
--- a/crates/horizon-client/src/mobs/goals.rs
+++ b/crates/horizon-client/src/mobs/goals.rs
@@ -588,24 +588,38 @@ impl Mob {
         if p.creative || p.allies.contains(&self.id) {
             return false;
         }
-        self.player_in_range(w, range, check_sight)
+        self.player_in_range(w, range, check_sight, true)
+    }
+    /// forCombat().ignoreInvisibilityTesting() for the player: the check for
+    /// a target the mob already has, which ignores the visibility scaling.
+    pub fn can_keep_target_player(&mut self, w: &MobWorld, range: f64) -> bool {
+        let Some(p) = &w.player else { return false };
+        if p.creative || p.allies.contains(&self.id) {
+            return false;
+        }
+        self.player_in_range(w, range, true, false)
     }
     /// TargetingConditions.forNonCombat().range(range).test for the player
     /// (seen by anyone, within range scaled by visibility, in sight).
     pub fn can_see_player(&mut self, w: &MobWorld, range: f64) -> bool {
-        self.player_in_range(w, range, true)
+        self.player_in_range(w, range, true, true)
     }
-    fn player_in_range(&mut self, w: &MobWorld, range: f64, check_sight: bool) -> bool {
+    /// `scale` is `TargetingConditions.testInvisible`: scale the range by
+    /// the player's visibility.
+    fn player_in_range(
+        &mut self,
+        w: &MobWorld,
+        range: f64,
+        check_sight: bool,
+        scale: bool,
+    ) -> bool {
         let Some(p) = &w.player else { return false };
         if !p.alive || p.spectator {
             return false;
         }
         // LivingEntity.getVisibilityPercent
-        let mut visibility = 1.0;
-        if p.sneaking {
-            visibility *= 0.8;
-        }
-        if let Some(head) = &p.head {
+        let mut visibility = if scale { p.visibility_percent() } else { 1.0 };
+        if let Some(head) = p.head.as_ref().filter(|_| scale) {
             let skull = match self.species() {
                 Species::Zombie | Species::Husk | Species::Drowned | Species::ZombieVillager => {
                     "minecraft:zombie_head"
@@ -1017,6 +1031,8 @@ pub struct MeleeAttack {
     pub speed: f64,
     pub follow_unseen: bool,
     pub zombie: bool,
+    /// `PolarBear.PolarBearMeleeAttackGoal`: rears up before each strike.
+    pub polar_bear: bool,
     path_target: [f64; 3],
     recalc: i32,
     pub until_attack: i32,
@@ -1031,6 +1047,7 @@ impl MeleeAttack {
             speed,
             follow_unseen,
             zombie: false,
+            polar_bear: false,
             path_target: [0.0; 3],
             recalc: 0,
             until_attack: 0,
@@ -1043,6 +1060,10 @@ impl MeleeAttack {
         self.zombie = true;
         self
     }
+    pub fn polar_bear(mut self) -> Self {
+        self.polar_bear = true;
+        self
+    }
     pub fn interval(mut self, ticks: i32) -> Self {
         self.interval = ticks;
         self
@@ -1098,6 +1119,9 @@ impl Goal for MeleeAttack {
         }
         m.ai.aggressive = false;
         m.nav_stop();
+        if self.polar_bear {
+            super::polar_bear::set_standing(m, false);
+        }
     }
     fn every_tick(&self) -> bool {
         true
@@ -1131,7 +1155,17 @@ impl Goal for MeleeAttack {
             self.recalc = adjusted(true, self.recalc);
         }
         self.until_attack = (self.until_attack - 1).max(0);
-        if self.until_attack <= 0 && m.within_melee_range(&t) && m.sees(cx.w, who) {
+        if self.polar_bear {
+            let cooldown = adjusted(true, self.interval);
+            super::polar_bear::check_and_perform_attack(
+                &mut self.until_attack,
+                cooldown,
+                m,
+                who,
+                &t,
+                cx,
+            );
+        } else if self.until_attack <= 0 && m.within_melee_range(&t) && m.sees(cx.w, who) {
             self.until_attack = adjusted(true, self.interval);
             m.swing();
             super::ai::do_hurt_target(m, who, cx);
@@ -1210,6 +1244,9 @@ pub struct NearestTarget {
     pub interval: i32,
     /// Extra condition on the attacker, checked after the random interval.
     pub when: Option<fn(&Mob, &MobWorld) -> bool>,
+    /// Mobs closer than this squared distance are not picked
+    /// (`GuardianAttackSelector`: `distanceToSqr > 9`).
+    pub beyond_sqr: Option<f64>,
     /// A condition checked before anything else, by subclasses overriding
     /// `canUse` (SpiderTargetGoal: only in the dark).
     pub gate: Option<fn(&Mob, &MobWorld) -> bool>,
@@ -1242,6 +1279,7 @@ impl NearestTarget {
             must_reach: false,
             interval: reduced(10),
             when: None,
+            beyond_sqr: None,
             gate: None,
             label: None,
             found: None,
@@ -1274,6 +1312,10 @@ impl NearestTarget {
         self.when = Some(f);
         self
     }
+    pub fn beyond(mut self, distance_sqr: f64) -> Self {
+        self.beyond_sqr = Some(distance_sqr);
+        self
+    }
     pub fn gate(mut self, f: fn(&Mob, &MobWorld) -> bool) -> Self {
         self.gate = Some(f);
         self
@@ -1284,9 +1326,25 @@ impl NearestTarget {
         self
     }
 }
+/// `AbstractIllager.canAttack`: a baby `AbstractVillager` is never attacked.
+fn illager_spares(attacker: Species, target: &Seen) -> bool {
+    matches!(
+        attacker,
+        Species::Pillager | Species::Vindicator | Species::Evoker | Species::Illusioner
+    ) && target.baby
+        && matches!(target.species, Species::Villager | Species::WanderingTrader)
+}
 /// TargetGoal.canContinueToUse
 pub fn target_continue(st: &mut TargetState, must_see: bool, m: &mut Mob, cx: &mut Cx) -> bool {
     let Some(who) = m.ai.target else { return false };
+    if let Who::Mob(id) = who
+        && cx
+            .w
+            .seen(id)
+            .is_some_and(|s| illager_spares(m.species(), s))
+    {
+        return false;
+    }
     let Some(t) = cx.w.target_info(who) else {
         return false;
     };
@@ -1345,10 +1403,12 @@ impl Goal for NearestTarget {
             prey => {
                 let pos = Vec3::new(m.position.x, m.eye_y(), m.position.z);
                 let id = m.id;
+                let attacker = m.species();
                 let candidates: Vec<(u32, Vec3)> =
                     cx.w.nearby(pos, range, move |s| {
                         s.id != id
                             && !s.playing_dead
+                            && !illager_spares(attacker, s)
                             && match prey {
                                 Prey::Species(list) => list.contains(&s.species),
                                 Prey::Filter(f) => f(s),
@@ -1361,6 +1421,9 @@ impl Goal for NearestTarget {
                     if m.distance_sqr(cpos) > range * range {
                         continue;
                     }
+                    if self.beyond_sqr.is_some_and(|d| m.distance_sqr(cpos) <= d) {
+                        continue;
+                    }
                     if !m.sees(cx.w, Who::Mob(cid)) {
                         continue;
                     }
@@ -1393,6 +1456,9 @@ pub struct HurtByTarget {
     /// `Bee.BeeHurtByOtherGoal`: kept only while angry, and alerting others
     /// only when the attacker is in sight.
     pub bee: bool,
+    /// `PolarBear.PolarBearHurtByTargetGoal`: a hurt cub only calls the
+    /// adult bears and drops the target itself.
+    pub polar_bear: bool,
     timestamp: i32,
     st: TargetState,
 }
@@ -1403,6 +1469,7 @@ impl HurtByTarget {
             alert_except: vec![],
             ignore: vec![],
             bee: false,
+            polar_bear: false,
             timestamp: 0,
             st: TargetState {
                 unseen_memory: 300,
@@ -1422,6 +1489,10 @@ impl HurtByTarget {
         self.bee = true;
         self
     }
+    pub fn polar_bear(mut self) -> Self {
+        self.polar_bear = true;
+        self
+    }
 }
 impl Default for HurtByTarget {
     fn default() -> Self {
@@ -1433,6 +1504,8 @@ impl Goal for HurtByTarget {
     fn name(&self) -> &'static str {
         if self.bee {
             "BeeHurtByOtherGoal"
+        } else if self.polar_bear {
+            "PolarBearHurtByTargetGoal"
         } else {
             "HurtByTarget"
         }
@@ -1471,7 +1544,9 @@ impl Goal for HurtByTarget {
         self.timestamp = m.ai.last_hurt_by_time;
         self.st.unseen_memory = 300;
         self.st.unseen = 0;
-        if self.alert
+        // PolarBearHurtByTargetGoal.start: a cub alerts the adults itself.
+        let cub = self.polar_bear && m.is_baby();
+        if (self.alert || cub)
             && let Some(by) = m.ai.target
         {
             let range = m.attrs.follow_range;
@@ -1491,6 +1566,8 @@ impl Goal for HurtByTarget {
                             && (s.position.z - pos.z).abs() <= range + 1.0
                     })
                     .filter(|s| !self.alert_except.contains(&s.species))
+                    // PolarBearHurtByTargetGoal.alertOther: adults only.
+                    .filter(|s| !(self.polar_bear && s.baby))
                     .filter(|s| Who::Mob(s.id) != by)
                     .map(|s| s.id)
                     .collect();
@@ -1505,6 +1582,9 @@ impl Goal for HurtByTarget {
                 });
             }
         }
+        if cub {
+            m.ai.target = None;
+        }
     }
     fn stop(&mut self, m: &mut Mob, _: &mut Cx) {
         m.ai.target = None;
@@ -1712,7 +1792,7 @@ impl Goal for Tempt {
     }
     fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
         let Some(p) = cx.w.player.clone() else { return };
-        let (y, x) = (m.kind.max_head_y_rot + 20.0, m.kind.max_head_x_rot);
+        let (y, x) = (m.kind.max_head_y_rot + 20.0, m.max_head_x_rot());
         m.look_at_speed(p.eye, y, x);
         if m.distance_sqr(p.position) < self.stop_distance * self.stop_distance {
             m.nav_stop();
@@ -1762,6 +1842,10 @@ impl Goal for Breed {
         if tamable && (!m.extra.tame || m.extra.sitting) {
             return false;
         }
+        // TurtleBreedGoal.canUse: not while carrying an egg.
+        if species == Species::Turtle && super::turtle::has_egg(m) {
+            return false;
+        }
         let id = m.id;
         // Horses and donkeys breed together (AbstractHorse.canParent: tame).
         // Sniffer.canMate: calm states only.
@@ -1771,11 +1855,16 @@ impl Goal for Breed {
         }
         let llama = super::llama::is_llama(species);
         let equine = matches!(species, Species::Horse | Species::Donkey) || llama;
-        if equine && !m.extra.tame {
-            return false;
-        }
-        // Llama.canParent: not ridden, and at full health.
-        if llama && (m.rider.is_some() || m.health < m.attrs.max_health) {
+        // AbstractHorse.canParent: tame, an adult, not a vehicle or passenger
+        // and at full health.
+        if equine
+            && (!m.extra.tame
+                || m.is_baby()
+                || m.rider.is_some()
+                || m.extra.rider.is_some()
+                || m.extra.mount.is_some()
+                || m.health < m.attrs.max_health)
+        {
             return false;
         }
         self.partner =
@@ -1788,7 +1877,10 @@ impl Goal for Breed {
                     && s.in_love
                     && !s.baby
                     && (!tamable || s.tame)
-                    && (!equine || s.tame)
+                    // Wolf.canMate: a sitting wolf is no partner.
+                    && !(species == Species::Wolf && s.sitting)
+                    // AbstractHorse.canParent of the partner.
+                    && (!equine || s.tame && !s.ridden && s.health >= s.stats[0] as f32)
                     && (!sniffer || super::sniffer::can_mate_state(s.variant))
             })
             .map(|s| s.id)
@@ -1809,7 +1901,7 @@ impl Goal for Breed {
         let Some(p) = self.partner.and_then(|p| cx.w.seen(p)).cloned() else {
             return;
         };
-        let x = m.kind.max_head_x_rot;
+        let x = m.max_head_x_rot();
         m.look_at_speed([p.position.x, p.eye_y, p.position.z], 10.0, x);
         m.nav_move_to_entity(
             cx.w,
@@ -1832,6 +1924,10 @@ impl Goal for Breed {
             });
             m.extra.in_love = 0;
             m.extra.age = 6000;
+            // TurtleBreedGoal.breed: the mother carries an egg, not a baby.
+            if m.species() == Species::Turtle {
+                m.extra.flag = true;
+            }
             cx.events.push(MobEvent::Breed {
                 parent: m.id,
                 partner: p.id,
diff --git a/crates/horizon-client/src/mobs/guardian.rs b/crates/horizon-client/src/mobs/guardian.rs
index 9704de044..b630aeadd 100644
--- a/crates/horizon-client/src/mobs/guardian.rs
+++ b/crates/horizon-client/src/mobs/guardian.rs
@@ -61,7 +61,8 @@ pub fn register(m: &mut Mob) {
         NearestTarget::species(
             &[Species::Squid, Species::GlowSquid, Species::Axolotl],
             true,
-        ),
+        )
+        .beyond(9.0),
     );
 }
 /// `GuardianAttackGoal`.
@@ -120,9 +121,11 @@ impl Goal for GuardianAttack {
                 1.0,
             ));
         } else if self.attack_time >= attack_duration(m) {
-            // Indirect magic (1, +2 for the elder; NORMAL difficulty), then
+            // Indirect magic (1, +2 on Hard, +2 for the elder), then
             // doHurtTarget.
-            let magic = if is_elder(m) { 3.0 } else { 1.0 };
+            let magic = 1.0
+                + if cx.w.difficulty.hard { 2.0 } else { 0.0 }
+                + if is_elder(m) { 2.0 } else { 0.0 };
             let from = [m.position.x, m.position.y, m.position.z];
             match who {
                 Who::Player => cx.events.push(MobEvent::DamagePlayer {
@@ -396,6 +399,8 @@ pub fn beam_geometry(
             layer: 0,
             color,
             light: 240 | 240 << 8,
+
+            glint_uv: [0.0, 0.0],
         });
     };
     // Sides: one quad per texture repeat.
diff --git a/crates/horizon-client/src/mobs/happy_ghast.rs b/crates/horizon-client/src/mobs/happy_ghast.rs
index bd4c5b1f3..418556750 100644
--- a/crates/horizon-client/src/mobs/happy_ghast.rs
+++ b/crates/horizon-client/src/mobs/happy_ghast.rs
@@ -364,8 +364,7 @@ impl Goal for GhastTempt {
         let Some(p) = &cx.w.player else { return false };
         // getNearestPlayer(TargetingConditions.forNonCombat()
         // .ignoreLineOfSight().range(TEMPT_RANGE 16)): creative players too.
-        let visibility = if p.sneaking { 0.8 } else { 1.0 };
-        let range = (16.0_f64 * visibility).max(2.0);
+        let range = (16.0_f64 * p.visibility_percent()).max(2.0);
         p.alive
             && !p.spectator
             && (Self::wants(m, &p.main_hand) || Self::wants(m, &p.off_hand))
@@ -544,14 +543,15 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld) {
             m.ai.home = Some((here, radius));
         }
     }
-    // continuousHeal: a point every 30 seconds, every second in rain.
+    // continuousHeal: a point every 30 seconds, every second in rain or snow
+    // (Level.precipitationAt).
     if m.alive() && m.death_time == 0 && m.health < m.attrs.max_health {
         let (x, y, z) = (
             m.position.x.floor() as i32,
             m.position.y.floor() as i32,
             m.position.z.floor() as i32,
         );
-        let wet = w.raining && w.can_see_sky(x, y, z);
+        let wet = w.precipitation_at(x, y, z).is_some();
         let interval = if wet { 20 } else { 600 };
         if m.age.is_multiple_of(interval) {
             m.health = (m.health + 1.0).min(m.attrs.max_health);
diff --git a/crates/horizon-client/src/mobs/hostile.rs b/crates/horizon-client/src/mobs/hostile.rs
index 0d3feaa6c..34dc256f9 100644
--- a/crates/horizon-client/src/mobs/hostile.rs
+++ b/crates/horizon-client/src/mobs/hostile.rs
@@ -177,9 +177,14 @@ pub fn creeper_tick(m: &mut Mob, events: &mut Vec<MobEvent>) {
     if m.swell >= 30 {
         m.swell = 30;
         let radius = if m.extra.charged { 6.0 } else { 3.0 };
+        events.push(MobEvent::ExplosionSource {
+            mob: m.id,
+            charged: m.extra.charged,
+        });
         events.push(MobEvent::Explode(
             [m.position.x, m.position.y, m.position.z],
             radius,
+            m.species(),
         ));
         m.removed = true;
     }
diff --git a/crates/horizon-client/src/mobs/illager.rs b/crates/horizon-client/src/mobs/illager.rs
index 45ef076d3..00581d6d3 100644
--- a/crates/horizon-client/src/mobs/illager.rs
+++ b/crates/horizon-client/src/mobs/illager.rs
@@ -72,6 +72,8 @@ pub fn register_vindicator(m: &mut Mob) {
     let g = &mut m.ai.goals;
     g.add(0, Float);
     g.add(1, avoid_creaking(1.0, 1.2));
+    g.add(2, super::doors::BreakDoor::vindicator());
+    g.add(3, super::doors::RaiderOpenDoor::default());
     g.add(4, super::raider::HoldGroundAttack::new(10.0));
     g.add(5, MeleeAttack::new(1.0, false));
     g.add(8, Stroll::new(0.6));
@@ -86,6 +88,13 @@ pub fn register_vindicator(m: &mut Mob) {
             .when(|m, _| m.custom_name.as_deref() == Some("Johnny")),
     );
 }
+/// `Vindicator.customServerAiStep`: its navigation opens doors while a raid
+/// is at its position.
+pub fn vindicator_server_ai_step(m: &mut Mob) {
+    if super::doors::can_navigate_ground(m) {
+        m.ai.nav.can_open_doors = super::raider::state(m).is_some_and(|s| s.raided);
+    }
+}
 // Evoker state: `counter` spellCastingTickCount, `variant2` the spell
 // being cast (0 none, 1 vexes, 2 fangs, 3 wololo), `counter2` the wololo
 // sheep's id.
@@ -179,8 +188,8 @@ impl Goal for UseSpell {
     fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
         let age = i64::from(m.age);
         if self.spell == Spell::Wololo {
-            // EvokerWololoSpellGoal.canUse: a blue sheep within 16 (4 up or
-            // down), no target, griefing on.
+            // EvokerWololoSpellGoal.canUse: a blue sheep within the box
+            // (16 sideways, 4 up or down) and `range(16)`, no target, griefing on.
             if m.ai.target.is_some() || m.extra.counter > 0 || age < self.next || !cx.w.mob_griefing
             {
                 return false;
@@ -196,6 +205,7 @@ impl Goal for UseSpell {
                             && (s.position.x - p.x).abs() <= 16.0
                             && (s.position.y - p.y).abs() <= 4.0
                             && (s.position.z - p.z).abs() <= 16.0
+                            && s.position.distance_squared(p) <= 16.0 * 16.0
                     })
                     .map(|s| s.id)
                     .collect();
@@ -210,7 +220,8 @@ impl Goal for UseSpell {
             return false;
         }
         if self.spell == Spell::Vexes {
-            // EvokerSummonSpellGoal: fewer vexes nearby than a roll of 1..8.
+            // EvokerSummonSpellGoal: fewer vexes within `range(16)` than a
+            // roll of 1..8.
             let p = m.position;
             let vexes =
                 cx.w.others
@@ -218,7 +229,7 @@ impl Goal for UseSpell {
                     .filter(|s| {
                         s.species == Species::Vex
                             && s.alive
-                            && s.position.distance_squared(p) <= 16.0 * 16.0 * 3.0
+                            && s.position.distance_squared(p) <= 16.0 * 16.0
                     })
                     .count() as i32;
             return m.random.next_int_bound(8).unwrap_or(0) + 1 > vexes;
@@ -670,7 +681,12 @@ pub fn anim_pose(m: &Mob, s: &State, p: &mut Poses, pose: ArmPose) {
                 p.xrot("right_arm", x + a * 1.2 - b * 0.4);
                 p.xrot("left_arm", x + a * 1.2 - b * 0.4);
             } else {
-                // swingWeaponDown (right-handed).
+                // swingWeaponDown: the main arm swings down.
+                let (main, off) = if m.main_arm_left() {
+                    ("left_arm", "right_arm")
+                } else {
+                    ("right_arm", "left_arm")
+                };
                 let swing = s.swing;
                 let a2 = (swing * PI).msin();
                 let a = ((1.0 - (1.0 - swing) * (1.0 - swing)) * PI).msin();
@@ -679,11 +695,11 @@ pub fn anim_pose(m: &Mob, s: &State, p: &mut Poses, pose: ArmPose) {
                 p.yrot("right_arm", PI / 20.0);
                 p.yrot("left_arm", -PI / 20.0);
                 p.xrot(
-                    "right_arm",
+                    main,
                     -1.884_955_8 + (s.age * 0.09).mcos() * 0.15 + (a2 * 2.2 - a * 0.4),
                 );
                 p.xrot(
-                    "left_arm",
+                    off,
                     -0.0 + (s.age * 0.19).mcos() * 0.5 + (a2 * 1.2 - a * 0.4),
                 );
             }
diff --git a/crates/horizon-client/src/mobs/living.rs b/crates/horizon-client/src/mobs/living.rs
index 394821ace..10388d0c0 100644
--- a/crates/horizon-client/src/mobs/living.rs
+++ b/crates/horizon-client/src/mobs/living.rs
@@ -9,8 +9,15 @@ use crate::{
 };
 use horizon_core::{
     geometry::{Aabb, Vec3, trig},
+    position::BlockPos,
     random::RandomSource,
 };
+use horizon_world::{
+    entity_fluid::{CurrentAccumulator, CurrentTarget},
+    fluid::{FluidKind, FluidState},
+    fluid_flow::{FluidFlowWorld, flow_at},
+    registry::BlockStateId,
+};
 
 /// `Entity.moveDist`, `flyDist` and `nextStep`.
 #[derive(Clone, Copy, Debug)]
@@ -36,6 +43,50 @@ pub struct Fluids {
     pub in_lava: bool,
     pub eye_in_water: bool,
 }
+/// `FluidFlowWorld` over the mob's scene: the neighbours a flow vector reads.
+struct FlowScene<'a, 'w>(&'a MobWorld<'w>);
+impl FluidFlowWorld for FlowScene<'_, '_> {
+    type Error = std::convert::Infallible;
+    type Block = BlockStateId;
+    fn fluid(&mut self, p: BlockPos) -> Result<FluidState, Self::Error> {
+        Ok(self.0.fluid_tables.fluid(self.0.world.block(p.x, p.y, p.z)))
+    }
+    fn block(&mut self, p: BlockPos) -> Result<BlockStateId, Self::Error> {
+        Ok(self.0.world.block(p.x, p.y, p.z))
+    }
+    fn blocks_fluid_flow(&self, s: BlockStateId) -> bool {
+        self.0.fluid_tables.blocks_flow(s)
+    }
+    fn is_ice_class(&self, s: BlockStateId) -> bool {
+        self.0.fluid_tables.ice(s)
+    }
+    fn is_face_sturdy(
+        &mut self,
+        s: BlockStateId,
+        _: BlockPos,
+        d: horizon_core::geometry::Direction,
+    ) -> Result<bool, Self::Error> {
+        Ok(self.0.fluid_tables.sturdy(s, d))
+    }
+}
+/// The mob's velocity, for `CurrentAccumulator::apply_to`.
+struct Pushed<'a>(&'a mut Vec3);
+impl CurrentTarget for Pushed<'_> {
+    type Error = std::convert::Infallible;
+    fn is_player_class(&self) -> bool {
+        false
+    }
+    fn velocity(&mut self) -> Result<Vec3, Self::Error> {
+        Ok(*self.0)
+    }
+    fn add_delta_movement(&mut self, delta: Vec3) -> Result<(), Self::Error> {
+        let sum = Vec3::new(self.0.x + delta.x, self.0.y + delta.y, self.0.z + delta.z);
+        if delta.is_finite() && sum.is_finite() {
+            *self.0 = sum;
+        }
+        Ok(())
+    }
+}
 pub fn wrap(a: f32) -> f32 {
     let mut a = a % 360.0;
     if a >= 180.0 {
@@ -140,6 +191,40 @@ impl MobWorld<'_> {
         }
         out
     }
+    /// Entity.updateFluidHeightAndDoFluidPushing's currents over the deflated
+    /// box: the flow of every water and lava block it touches, summed (a thin
+    /// fluid layer scales its flow down), as (water, lava).
+    fn fluid_currents(&self, bounds: Aabb) -> (CurrentAccumulator, CurrentAccumulator) {
+        let base_y = bounds.min_position().y;
+        let b = bounds.deflate(Vec3::new(0.001, 0.001, 0.001));
+        let (lo, hi) = (b.min_position(), b.max_position());
+        let mut scene = FlowScene(self);
+        let (mut water, mut lava) = (CurrentAccumulator::default(), CurrentAccumulator::default());
+        for x in lo.x.floor() as i32..=(hi.x.ceil() as i32 - 1) {
+            for y in lo.y.floor() as i32..=(hi.y.ceil() as i32 - 1) {
+                for z in lo.z.floor() as i32..=(hi.z.ceil() as i32 - 1) {
+                    let p = BlockPos::new(x, y, z);
+                    let state = self.fluid_tables.fluid(self.world.block(x, y, z));
+                    let current = match state.kind() {
+                        FluidKind::Empty => continue,
+                        FluidKind::Water | FluidKind::FlowingWater => &mut water,
+                        FluidKind::Lava | FluidKind::FlowingLava => &mut lava,
+                    };
+                    let surface = f64::from(y) + self.fluid_height(x, y, z).1;
+                    if surface < lo.y {
+                        continue;
+                    }
+                    current.height = current.height.max(surface - base_y);
+                    let mut flow = flow_at(&mut scene, state, p).unwrap_or(Vec3::ZERO);
+                    if current.height < 0.4 {
+                        flow = flow.scale(current.height);
+                    }
+                    current.accumulate(flow);
+                }
+            }
+        }
+        (water, lava)
+    }
     /// `BlockState.getCollisionShape(level, pos)` (the empty collision
     /// context) as boxes in the world.
     pub fn block_collision_boxes(&self, x: i32, y: i32, z: i32) -> Vec<Aabb> {
@@ -235,6 +320,26 @@ impl MobWorld<'_> {
         };
         scene.unobstructed(b).unwrap_or(false)
     }
+    /// `LevelReader.containsAnyLiquid`: the blocks from the box's minimum
+    /// corner to the block holding its maximum corner.
+    pub fn contains_any_liquid(&self, b: Aabb) -> bool {
+        let (lo, hi) = (b.min_position(), b.max_position());
+        let (x0, y0, z0) = (
+            lo.x.floor() as i32,
+            lo.y.floor() as i32,
+            lo.z.floor() as i32,
+        );
+        let (x1, y1, z1) = (
+            hi.x.floor() as i32,
+            hi.y.floor() as i32,
+            hi.z.floor() as i32,
+        );
+        (x0..=x1).any(|x| {
+            (y0..=y1).any(|y| {
+                (z0..=z1).any(|z| self.facts.get(self.world.block(x, y, z)).fluid != Fluid::None)
+            })
+        })
+    }
 }
 impl Mob {
     /// `Entity.refreshDimensions` after growing from `old_w` by `old_h`:
@@ -281,6 +386,15 @@ impl Mob {
             return (f64::from(0.2_f32), f64::from(0.2_f32), f64::from(0.2_f32));
         }
         let k = &self.kind;
+        // Avatar.POSES: a player's or mannequin's box follows its pose.
+        if matches!(&*k.id, "minecraft:player" | "minecraft:mannequin") {
+            let d = self.extra.avatar_pose.dimensions(1.0);
+            return (
+                f64::from(d.width),
+                f64::from(d.height),
+                f64::from(d.eye_height),
+            );
+        }
         let (mut w, mut h, mut e) = (k.width as f32, k.height as f32, k.eye_height as f32);
         // Sniffer.DIGGING_DIMENSIONS: 0.4 lower, its eyes at 0.81.
         if k.species == super::Species::Sniffer && super::sniffer::digging(self) {
@@ -334,6 +448,27 @@ impl Mob {
     pub fn is_in_liquid(&self) -> bool {
         self.fluids.in_water || self.fluids.in_lava
     }
+    /// `Entity.isPushedByFluid`: water animals, turtles, axolotls, frogs and
+    /// nautiluses keep their own course.
+    fn pushed_by_fluid(&self) -> bool {
+        use super::Species as S;
+        !matches!(
+            self.species(),
+            S::Tadpole
+                | S::Cod
+                | S::Salmon
+                | S::TropicalFish
+                | S::Pufferfish
+                | S::Squid
+                | S::GlowSquid
+                | S::Dolphin
+                | S::Turtle
+                | S::Axolotl
+                | S::Frog
+                | S::Nautilus
+                | S::ZombieNautilus
+        )
+    }
     fn affected_by_fluids(&self) -> bool {
         true
     }
@@ -428,6 +563,17 @@ impl Mob {
         // Entity.checkSupportingBlock
         self.supporting = self.supporting_block(w, moved);
         self.movement_emission(w, moved, events);
+        // Entity.applyEffectsFromBlocks: bubble columns push the mob.
+        if crate::motion::bubble_column_push(
+            w.world,
+            w.registry,
+            w.facts,
+            w.collision,
+            self.bounds(),
+            &mut self.velocity,
+        ) {
+            self.fall_distance = 0.0;
+        }
     }
     /// LivingEntity.checkFallDamage: the fluid state refreshed out of water
     /// (touching water resets the fall), then Entity.checkFallDamage.
@@ -440,16 +586,57 @@ impl Mob {
         }
         if self.on_ground {
             if self.fall_distance > 0.0 {
+                self.trample_farmland(w, events);
                 self.cause_fall_damage(events);
             }
             self.fall_distance = 0.0;
         }
     }
+    /// `FarmlandBlock.fallOn`: a landing on farmland turns it to dirt with
+    /// chance `fallDistance - 0.5`, if mobs may grief and the mob's
+    /// `width * width * height` is over 0.512. `Block.pushEntitiesUp` lifts
+    /// the mob onto the dirt, which is a full block.
+    fn trample_farmland(&mut self, w: &MobWorld, events: &mut Vec<MobEvent>) {
+        let p = self.block_on_legacy(w);
+        if w.block_name(p[0], p[1], p[2]) != "minecraft:farmland" {
+            return;
+        }
+        let roll = f64::from(self.random.next_float());
+        let Some(dirt) = w.registry.default_state("minecraft:dirt") else {
+            return;
+        };
+        if roll < self.fall_distance - 0.5
+            && w.mob_griefing
+            && self.width() * self.width() * self.height() > 0.512
+        {
+            events.push(MobEvent::SetBlock {
+                pos: p,
+                state: dirt,
+            });
+            self.position.y = self.position.y.max(f64::from(p[1]) + 1.0);
+        }
+    }
     /// Entity.updateFluidInteraction: the fluid state, then touching water
     /// resets the fall and entering it (after the first tick) splashes.
     pub(super) fn update_fluids(&mut self, w: &MobWorld, events: &mut Vec<MobEvent>) {
         let was_touching_water = self.fluids.in_water;
         self.fluids = w.fluids(self.bounds(), self.eye_y());
+        // EntityFluidInteraction.applyCurrentTo: the flow pushes the mob.
+        if (self.fluids.in_water || self.fluids.in_lava) && self.pushed_by_fluid() {
+            let (water, lava) = w.fluid_currents(self.bounds());
+            let lava_scale = if w.nether {
+                0.007
+            } else {
+                0.0023333333333333335
+            };
+            let mut pushed = Pushed(&mut self.velocity);
+            if water.height > 0.0 {
+                let _ = water.apply_to(&mut pushed, 0.014);
+            }
+            if lava.height > 0.0 {
+                let _ = lava.apply_to(&mut pushed, lava_scale);
+            }
+        }
         if self.fluids.in_water {
             self.fall_distance = 0.0;
             if !was_touching_water && !self.first_tick {
@@ -529,13 +716,15 @@ impl Mob {
         }
     }
     /// `Entity.nextStep`: the next whole metre walked; a warden's steps come
-    /// every 0.55, a strider's every 0.6.
+    /// every 0.55, a strider's every 0.6, a turtle's every 0.15.
     fn next_step(&self) -> f32 {
         let walked = self.ai.steps.move_dist;
         if self.kind.species == super::Species::Warden {
             walked + 0.55
         } else if self.kind.species == super::Species::Strider {
             walked + 0.6
+        } else if self.kind.species == super::Species::Turtle {
+            walked + 0.15
         } else {
             (walked as i32).wrapping_add(1) as f32
         }
@@ -629,7 +818,11 @@ impl Mob {
             return;
         }
         let power = self.fall_distance + 1.0e-6 - self.kind.safe_fall_distance;
-        let damage = (power * self.kind.fall_damage_multiplier).floor();
+        let mut damage = (power * self.kind.fall_damage_multiplier).floor();
+        // Frog.calculateFallDamage: five points less than the base damage.
+        if self.species() == super::Species::Frog {
+            damage -= 5.0;
+        }
         if damage > 0.0 {
             let at = [self.position.x, self.position.y, self.position.z];
             let sound = if damage > 4.0 {
@@ -813,14 +1006,24 @@ impl Mob {
                 self.velocity.y -= gravity / 4.0;
             }
         }
-        // jumpOutOfFluid
+        // jumpOutOfFluid: Entity.isFree wants the box dry and clear of the
+        // entities a mob collides with (canBeCollidedWith: living shulkers).
         let m = self.velocity;
+        let ahead = self.bounds().move_by(Vec3::new(
+            m.x,
+            m.y + f64::from(0.6_f32) - self.position.y + old_y,
+            m.z,
+        ));
+        let wide = ahead.inflate(Vec3::new(1.0e-7, 1.0e-7, 1.0e-7));
         if self.horizontal_collision
-            && w.no_collision(self.bounds().move_by(Vec3::new(
-                m.x,
-                m.y + f64::from(0.6_f32) - self.position.y + old_y,
-                m.z,
-            )))
+            && w.no_collision(ahead)
+            && !w.contains_any_liquid(ahead)
+            && !w.others_near(wide).any(|s| {
+                s.id != self.id
+                    && s.alive
+                    && s.species == super::Species::Shulker
+                    && s.bounds.intersects(wide)
+            })
         {
             self.velocity.y = f64::from(0.3_f32);
         }
@@ -908,7 +1111,7 @@ impl Mob {
                 (distance * 4.0).min(1.0)
             };
             self.limb_speed += (target - self.limb_speed) * 0.4;
-            self.limb_position += self.limb_speed * if self.is_baby() { 3.0 } else { 1.0 };
+            self.limb_position += self.limb_speed;
         } else {
             self.limb_speed = 0.0;
         }
diff --git a/crates/horizon-client/src/mobs/monster_brain.rs b/crates/horizon-client/src/mobs/monster_brain.rs
index 9456c00a1..8be270ec1 100644
--- a/crates/horizon-client/src/mobs/monster_brain.rs
+++ b/crates/horizon-client/src/mobs/monster_brain.rs
@@ -359,11 +359,14 @@ fn can_attack(m: &Mob, w: &MobWorld, who: Who) -> bool {
 /// `Sensor.isEntityAttackable`: `TargetingConditions.forCombat()` within the
 /// follow range, in sight.
 fn attackable(m: &mut Mob, w: &MobWorld, who: Who) -> bool {
+    // The current ATTACK_TARGET is tested with ignoreInvisibilityTesting.
+    let current = mem_ref(m).attack_target.value() == Some(who);
     let range = m.attrs.follow_range;
     if !can_attack(m, w, who) {
         return false;
     }
     match who {
+        Who::Player if current => m.can_keep_target_player(w, range),
         Who::Player => m.can_target_player(w, range, true),
         Who::Mob(id) => {
             let Some(s) = w.seen(id) else { return false };
@@ -1137,6 +1140,7 @@ struct Quarry {
     position: Vec3,
     head_yaw: f32,
     height: f64,
+    passenger: bool,
 }
 fn quarry(w: &MobWorld, who: Who) -> Option<Quarry> {
     let t = w.target_info(who)?;
@@ -1148,6 +1152,7 @@ fn quarry(w: &MobWorld, who: Who) -> Option<Quarry> {
         position: t.position,
         head_yaw,
         height: t.bounds.max_position().y - t.bounds.min_position().y,
+        passenger: t.passenger,
     })
 }
 /// `BreezeUtil.randomPointBehindTarget`.
@@ -1233,7 +1238,8 @@ fn shoot_tick(m: &mut Mob, cx: &mut Bx) {
     let firing = super::breeze::firing_y(m);
     let (xd, yd, zd) = (
         q.position.x - m.position.x,
-        q.position.y + q.height * 0.3 - firing,
+        // target.getY(target.isPassenger() ? 0.8 : 0.3).
+        q.position.y + q.height * if q.passenger { 0.8 } else { 0.3 } - firing,
         q.position.z - m.position.z,
     );
     let start = Vec3::new(m.position.x, firing, m.position.z);
@@ -1242,14 +1248,19 @@ fn shoot_tick(m: &mut Mob, cx: &mut Bx) {
         start,
         Some(Who::Mob(m.id)),
     );
-    // The new entity's own random spreads the shot (5 - difficulty * 4 at
-    // normal): not the breeze's.
+    // The new entity's own random spreads the shot (5 - difficulty id * 4):
+    // not the breeze's.
     let mut own = LegacyRandom::new(
         cx.now
             .wrapping_mul(0x5DEE_CE66)
             .wrapping_add(i64::from(m.id)),
     );
-    p.shoot(&mut own, [xd, yd, zd], 0.7, -3.0);
+    p.shoot(
+        &mut own,
+        [xd, yd, zd],
+        0.7,
+        5.0 - f32::from(cx.w.difficulty.id) * 4.0,
+    );
     cx.events.push(MobEvent::Projectile(p));
     breeze_sound(m, cx, "entity.breeze.shoot", 1.5);
 }
diff --git a/crates/horizon-client/src/mobs/piglin.rs b/crates/horizon-client/src/mobs/piglin.rs
index fff536932..b62262bb0 100644
--- a/crates/horizon-client/src/mobs/piglin.rs
+++ b/crates/horizon-client/src/mobs/piglin.rs
@@ -10,13 +10,19 @@ use super::{
     },
 };
 use horizon_core::geometry::{Vec3, trig::Mth};
-use horizon_core::random::RandomSource;
+use horizon_core::random::{LegacyRandom, RandomSource};
 use std::f32::consts::PI;
 
 /// `PiglinAi.ADMIRE_DURATION`.
 pub const ADMIRE: i32 = 119;
+/// `PiglinAi.eat`: the `ATE_RECENTLY` memory lasts 200 ticks (kept in
+/// `extra.ints[0]` of a piglin).
+pub const ATE_RECENTLY: i32 = 200;
 /// `AbstractPiglin.CONVERSION_TIME` (and the hoglin's).
 const CONVERSION: i32 = 300;
+/// `PiglinAi.CELEBRATION_TIME`: how long the `CELEBRATE_LOCATION` and
+/// `DANCING` memories last.
+const CELEBRATION: i32 = 300;
 
 fn hostile_to_player(m: &Mob, w: &MobWorld) -> bool {
     if m.is_baby() {
@@ -45,7 +51,9 @@ pub fn register_piglin(m: &mut Mob) {
         g.add(3, super::illager::crossbow_goal(1.0, 8.0));
     }
     g.add(3, MeleeAttack::new(1.0, true));
+    g.add(4, PiglinAvoidRepellent);
     g.add(4, GoToWantedItem);
+    g.add(4, Celebrate);
     g.add(5, Stroll::avoiding_water(0.6));
     g.add(6, LookAtPlayer::new(8.0));
     g.add(7, RandomLookAround::default());
@@ -176,6 +184,54 @@ impl Goal for BabyPanic {
         self.0.stop(m, cx)
     }
 }
+/// `PiglinAi.avoidRepellent`: `SetWalkTargetAwayFrom.pos(NEAREST_REPELLENT, 1.0, 8, false)`
+/// of the idle activity. Closer than 8 blocks to a repellent and not walking
+/// anywhere, walk away from it.
+#[derive(Clone, Debug)]
+struct PiglinAvoidRepellent;
+impl Goal for PiglinAvoidRepellent {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        MOVE
+    }
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        let Some(r) = m.extra.repellent else {
+            return false;
+        };
+        // The idle activity: not fighting or admiring, and no walk target yet.
+        if m.ai.target.is_some() || m.extra.using_item > 0 || !m.ai.nav.is_done() {
+            return false;
+        }
+        // Vec3.atBottomCenterOf.
+        let avoid = [
+            f64::from(r[0]) + 0.5,
+            f64::from(r[1]),
+            f64::from(r[2]) + 0.5,
+        ];
+        if m.distance_sqr(Vec3::new(avoid[0], avoid[1], avoid[2])) >= 64.0 {
+            return false;
+        }
+        for _ in 0..10 {
+            if let Some(p) = m.land_random_pos_away(cx.w, 16, 7, avoid) {
+                let at = [
+                    p[0].floor() as i32,
+                    p[1].floor() as i32,
+                    p[2].floor() as i32,
+                ];
+                m.ai.pending_path = m.create_path_to(cx.w, at, 0);
+                return m.ai.pending_path.is_some();
+            }
+        }
+        false
+    }
+    fn can_continue(&mut self, m: &mut Mob, _: &mut Cx) -> bool {
+        !m.ai.nav.is_done()
+    }
+    fn start(&mut self, m: &mut Mob, _: &mut Cx) {
+        let path = m.ai.pending_path.take();
+        m.nav_move_to_path(path, 1.0);
+    }
+}
 /// Admiring a gold item held in the off hand: stand and look at it.
 #[derive(Clone, Debug)]
 struct Admire;
@@ -191,6 +247,45 @@ impl Goal for Admire {
         m.nav_stop();
     }
 }
+/// The celebrate activity: `GoToTargetLocation` on the spot a killed target
+/// fell (within 2 blocks, or 4 and slower while dancing).
+#[derive(Clone, Debug)]
+struct Celebrate;
+impl Celebrate {
+    fn walk(m: &mut Mob, cx: &mut Cx) {
+        let Some(at) = m.extra.home else { return };
+        let (close, speed) = if m.extra.scratch[0] > 0 {
+            (4.0, 0.6)
+        } else {
+            (2.0, 1.0)
+        };
+        let center = Vec3::new(
+            f64::from(at[0]) + 0.5,
+            f64::from(at[1]),
+            f64::from(at[2]) + 0.5,
+        );
+        if m.distance_sqr(center) >= close * close {
+            m.nav_move_to(cx.w, [center.x, center.y, center.z], speed);
+        }
+    }
+}
+impl Goal for Celebrate {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        MOVE
+    }
+    fn can_use(&mut self, m: &mut Mob, _: &mut Cx) -> bool {
+        m.extra.scratch[1] > 0 && m.extra.home.is_some() && m.extra.using_item == 0
+    }
+    fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
+        Self::walk(m, cx);
+    }
+    fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
+        if m.ai.nav.is_done() {
+            Self::walk(m, cx);
+        }
+    }
+}
 /// `GoToWantedItem`: walk to the gold the game spotted.
 #[derive(Clone, Debug)]
 struct GoToWantedItem;
@@ -242,6 +337,54 @@ fn hoglin_repellent(m: &mut Mob, w: &MobWorld) {
         m.ai.target = None;
     }
 }
+/// `StartCelebratingIfTargetDead` for a piglin (`scratch[0]` dancing,
+/// `scratch[1]` ticks of celebration left, `scratch[2]` the hit seen, `home`
+/// the `CELEBRATE_LOCATION`): a killed target starts a celebration at its
+/// spot, and a hoglin's death makes the piglin dance one time in ten.
+/// `PiglinAi.wasHurtBy` ends both. Runs before the target goals drop the
+/// dead target.
+pub fn celebrate(m: &mut Mob, w: &MobWorld) {
+    if m.extra.scratch[1] > 0 {
+        m.extra.scratch[1] -= 1;
+        if m.extra.scratch[1] == 0 {
+            m.extra.scratch[0] = 0;
+            m.extra.home = None;
+        }
+    }
+    if let Some(by) = m.ai.last_hurt_by
+        && m.ai.last_hurt_by_time != m.extra.scratch[2]
+    {
+        m.extra.scratch[2] = m.ai.last_hurt_by_time;
+        // PiglinAi.wasHurtBy: another piglin's hit ends nothing.
+        let piglin =
+            matches!(by, Who::Mob(id) if w.seen(id).is_some_and(|s| s.species == Species::Piglin));
+        if !piglin {
+            m.extra.scratch[0] = 0;
+            m.extra.scratch[1] = 0;
+            m.extra.home = None;
+        }
+    }
+    if m.extra.scratch[1] > 0 {
+        return;
+    }
+    let Some(target) = m.ai.target else { return };
+    let Some(t) = w.target_info(target).filter(|t| !t.alive) else {
+        return;
+    };
+    let hoglin =
+        matches!(target, Who::Mob(id) if w.seen(id).is_some_and(|s| s.species == Species::Hoglin));
+    // PiglinAi.wantsToDance: a fresh random seeded with the game time, not
+    // the piglin's own.
+    if hoglin && LegacyRandom::new(w.game_time).next_float() < 0.1 {
+        m.extra.scratch[0] = 1;
+    }
+    m.extra.scratch[1] = CELEBRATION;
+    m.extra.home = Some([
+        t.position.x.floor() as i32,
+        t.position.y.floor() as i32,
+        t.position.z.floor() as i32,
+    ]);
+}
 /// Per-tick piglin and hoglin state: admiring, anger, zombification and the
 /// hoglin attack animation. Returns a conversion when it happens.
 pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
@@ -257,6 +400,9 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
             m.ai.target = None;
         }
     }
+    if m.species() == Species::Piglin && m.extra.ints[0] > 0 {
+        m.extra.ints[0] -= 1;
+    }
     // Admiring disabled after being hit by a player.
     if m.extra.egg_time > 0 {
         m.extra.egg_time -= 1;
@@ -299,6 +445,26 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     } else {
         m.extra.counter2 = 0;
     }
+    // PiglinSpecificSensor (every 20 ticks): the nearest repelling block.
+    if m.species() == Species::Piglin && m.alive() && m.age.wrapping_add(m.id).is_multiple_of(20) {
+        m.extra.repellent = find_piglin_repellent(m, w);
+    }
+}
+/// `PiglinSpecificSensor.findNearestRepellent`: the nearest `#piglin_repellents`
+/// block within 8 blocks sideways and 4 up or down; a soul campfire only
+/// counts while lit.
+fn find_piglin_repellent(m: &Mob, w: &MobWorld) -> Option<[i32; 3]> {
+    let tag = w.block_tags.get("minecraft:piglin_repellents")?;
+    let at = [
+        m.position.x.floor() as i32,
+        m.position.y.floor() as i32,
+        m.position.z.floor() as i32,
+    ];
+    w.nearest_block(at, 8, 4, |p, name| {
+        tag.contains(name)
+            && (name != "minecraft:soul_campfire"
+                || w.prop(p[0], p[1], p[2], "lit") == Some("true"))
+    })
 }
 /// `HoglinBase.hurtAndThrowTarget`.
 pub fn hoglin_hurt_target(m: &mut Mob, who: Who, cx: &mut Cx) {
@@ -345,7 +511,10 @@ pub fn ears(p: &mut Poses, s: &State) {
 /// Piglins' and brutes' ears flap (`AbstractPiglinModel`), arms follow the
 /// arm pose (`PiglinModel`).
 pub fn piglin_anim(m: &Mob, s: &State, p: &mut Poses) {
-    let pose = if m.extra.using_item > 0 {
+    // Piglin.getArmPose: dancing comes first.
+    let pose = if m.extra.scratch[0] > 0 {
+        PiglinPose::Dancing
+    } else if m.extra.using_item > 0 {
         PiglinPose::AdmiringItem
     } else if m.extra.flag {
         PiglinPose::CrossbowCharge
@@ -356,7 +525,14 @@ pub fn piglin_anim(m: &Mob, s: &State, p: &mut Poses) {
     } else {
         PiglinPose::Default
     };
-    piglin_pose(p, s, pose, 25.0, m.extra.using_item as f32);
+    piglin_pose(
+        p,
+        s,
+        pose,
+        25.0,
+        m.extra.using_item as f32,
+        m.main_arm_left(),
+    );
 }
 /// `PiglinArmPose`.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -368,11 +544,19 @@ pub enum PiglinPose {
     CrossbowCharge,
     AdmiringItem,
 }
-/// `PiglinModel.setupAnim` for a piglin facing right-handed.
-pub fn piglin_pose(p: &mut Poses, s: &State, pose: PiglinPose, max_charge: f32, ticks: f32) {
-    use super::anim::{ArmPose, Hum, humanoid};
+/// `PiglinModel.setupAnim`; `left` when the piglin's main arm is the left one.
+pub fn piglin_pose(
+    p: &mut Poses,
+    s: &State,
+    pose: PiglinPose,
+    max_charge: f32,
+    ticks: f32,
+    left: bool,
+) {
+    use super::anim::{ArmPose, Hum, crossbow_charge, crossbow_hold, humanoid};
     let mut h = Hum::new(ArmPose::Empty, ArmPose::Empty);
     h.weapon_swing = pose == PiglinPose::MeleeWeapon;
+    h.left_main = left;
     h.charge = (max_charge, ticks);
     humanoid(p, s, &h);
     ears(p, s);
@@ -399,27 +583,22 @@ pub fn piglin_pose(p: &mut Poses, s: &State, pose: PiglinPose, max_charge: f32,
             p.get("left_arm")[1] += (dance * 40.0).msin() * 0.5 + 0.5;
             p.get("body")[1] += (dance * 40.0).msin() * 0.35;
         }
-        PiglinPose::MeleeWeapon if s.swing == 0.0 => p.xrot("right_arm", -1.8),
-        PiglinPose::CrossbowHold => {
-            p.yrot("right_arm", -0.3 + hy);
-            p.yrot("left_arm", 0.6 + hy);
-            p.xrot("right_arm", -PI / 2.0 + hx + 0.1);
-            p.xrot("left_arm", -1.5 + hx);
-        }
-        PiglinPose::CrossbowCharge => {
-            p.yrot("right_arm", -0.8);
-            p.xrot("right_arm", -0.970_796_35);
-            p.xrot("left_arm", -0.970_796_35);
-            let alpha = ticks.clamp(0.0, max_charge) / max_charge;
-            p.yrot("left_arm", 0.4 + alpha * (0.85 - 0.4));
-            let x = -0.970_796_35 + alpha * (-PI / 2.0 - -0.970_796_35);
-            p.xrot("left_arm", x);
+        // holdWeaponHigh
+        PiglinPose::MeleeWeapon if s.swing == 0.0 => {
+            p.xrot(if left { "left_arm" } else { "right_arm" }, -1.8)
         }
+        PiglinPose::CrossbowHold => crossbow_hold(p, hx, hy, !left),
+        PiglinPose::CrossbowCharge => crossbow_charge(p, max_charge, ticks, !left),
         PiglinPose::AdmiringItem => {
             p.xrot("head", 0.5);
             p.yrot("head", 0.0);
-            p.yrot("left_arm", 0.5);
-            p.xrot("left_arm", -0.9);
+            if left {
+                p.yrot("right_arm", -0.5);
+                p.xrot("right_arm", -0.9);
+            } else {
+                p.yrot("left_arm", 0.5);
+                p.xrot("left_arm", -0.9);
+            }
         }
         _ => {}
     }
diff --git a/crates/horizon-client/src/mobs/polar_bear.rs b/crates/horizon-client/src/mobs/polar_bear.rs
new file mode 100644
index 000000000..bfd464a93
--- /dev/null
+++ b/crates/horizon-client/src/mobs/polar_bear.rs
@@ -0,0 +1,191 @@
+//! Polar bears (`PolarBear`): a neutral animal that defends its cubs,
+//! fights back when hurt, and rears up before each swing. A cub flees what
+//! hurts it and calls the adults.
+//!
+//! `extra.flag` is `DATA_STANDING_ID`, `extra.counter` the warning sound's
+//! delay, `extra.anger` the `NeutralMob` anger left and `extra.flag2` whether
+//! the player is who it is angry at. `anim.v[STAND]` is
+//! `clientSideStandAnimation`.
+use horizon_core::{geometry::Vec3, random::RandomSource};
+
+use super::{
+    DamageKind, Mob, MobWorld, Species, Who,
+    goals::{
+        Cx, Float, FollowParent, Goal, HurtByTarget, LookAtPlayer, MOVE, MeleeAttack,
+        NearestTarget, Panic, RandomLookAround, Stroll, goal_clone,
+    },
+    world::TargetInfo,
+};
+
+/// `anim.v` slot of `clientSideStandAnimation`.
+pub const STAND: usize = 0;
+/// `STAND_ANIMATION_TICKS`.
+const STAND_TICKS: f32 = 6.0;
+
+pub fn register(m: &mut Mob) {
+    let g = &mut m.ai.goals;
+    g.add(0, Float);
+    g.add(1, MeleeAttack::new(1.25, true).polar_bear());
+    g.add(1, PolarBearPanic(Panic::new(2.0)));
+    g.add(4, FollowParent::new(1.25));
+    g.add(5, Stroll::new(1.0));
+    g.add(6, LookAtPlayer::new(6.0));
+    g.add(7, RandomLookAround::default());
+    let t = &mut m.ai.targets;
+    t.add(1, HurtByTarget::new().polar_bear());
+    // PolarBearAttackPlayersGoal: players near a cub, within half the
+    // follow range, never for a cub itself.
+    t.add(
+        2,
+        NearestTarget::player(true)
+            .interval(20)
+            .follow_scale(0.5)
+            .reach()
+            .gate(|m, _| !m.is_baby())
+            .when(cub_nearby)
+            .named("PolarBearAttackPlayersGoal"),
+    );
+    t.add(
+        3,
+        NearestTarget::player(true).when(|m, _| m.extra.anger > 0 && m.extra.flag2),
+    );
+    t.add(
+        4,
+        NearestTarget::species(&[Species::Fox], true)
+            .interval(10)
+            .reach()
+            .when(|m, _| !m.is_baby()),
+    );
+}
+
+/// `PolarBearAttackPlayersGoal.canUse`: a polar bear cub within 8 blocks
+/// (4 up and down).
+fn cub_nearby(m: &Mob, w: &MobWorld) -> bool {
+    let area = m.bounds().inflate(Vec3::new(8.0, 4.0, 8.0));
+    w.others_near(area)
+        .any(|s| s.species == Species::PolarBear && s.baby && s.bounds.intersects(area))
+}
+
+/// `PanicGoal` with a function of the bear's age for the damage tag: a cub
+/// panics at `PANIC_CAUSES`, an adult only at `PANIC_ENVIRONMENTAL_CAUSES`.
+#[derive(Clone, Debug)]
+struct PolarBearPanic(Panic);
+impl Goal for PolarBearPanic {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        MOVE
+    }
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        (m.is_baby() || environmental_panic(m)) && self.0.can_use(m, cx)
+    }
+    fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        self.0.can_continue(m, cx)
+    }
+    fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
+        self.0.start(m, cx)
+    }
+    fn stop(&mut self, m: &mut Mob, cx: &mut Cx) {
+        self.0.stop(m, cx)
+    }
+}
+/// `DamageTypeTags.PANIC_ENVIRONMENTAL_CAUSES` (fire, lava, cactus), or
+/// burning.
+fn environmental_panic(m: &Mob) -> bool {
+    m.fire_ticks > 0 && !m.kind.flags.fire_immune
+        || m.last_damage.is_some_and(|(d, t)| {
+            matches!(
+                d.kind,
+                DamageKind::OnFire | DamageKind::InFire | DamageKind::Lava | DamageKind::Cactus
+            ) && i64::from(m.age) - t <= 40
+        })
+}
+
+/// `PolarBear.setStanding`.
+pub fn set_standing(m: &mut Mob, standing: bool) {
+    m.extra.flag = standing;
+}
+
+/// `PolarBear.playWarningSound`.
+fn play_warning_sound(m: &mut Mob, cx: &mut Cx) {
+    if m.extra.counter <= 0 {
+        m.voice("entity.polar_bear.warning", cx.events);
+        m.extra.counter = 40;
+    }
+}
+
+/// `PolarBearMeleeAttackGoal.checkAndPerformAttack`: strike when ready and
+/// in reach, rear up and growl in the last 10 ticks while close.
+pub fn check_and_perform_attack(
+    until_attack: &mut i32,
+    cooldown: i32,
+    m: &mut Mob,
+    who: Who,
+    t: &TargetInfo,
+    cx: &mut Cx,
+) {
+    if *until_attack <= 0 && m.within_melee_range(t) && m.sees(cx.w, who) {
+        *until_attack = cooldown;
+        super::ai::do_hurt_target(m, who, cx);
+        set_standing(m, false);
+        return;
+    }
+    let reach = t.bounds.size().x as f32 + 3.0;
+    if m.distance_sqr(t.position) < f64::from(reach * reach) {
+        if *until_attack <= 0 {
+            set_standing(m, false);
+            *until_attack = cooldown;
+        }
+        if *until_attack <= 10 {
+            set_standing(m, true);
+            play_warning_sound(m, cx);
+        }
+    } else {
+        *until_attack = cooldown;
+        set_standing(m, false);
+    }
+}
+
+/// `PolarBear.tick`'s client half: `clientSideStandAnimation` follows the
+/// synched standing flag by one tick a tick. A client of a server runs it
+/// too.
+pub fn client_tick(m: &mut Mob) {
+    let v = m.anim.v[STAND];
+    m.anim.vo[STAND] = v;
+    let step = if m.extra.flag { 1.0 } else { -1.0 };
+    m.anim.v[STAND] = (v + step).clamp(0.0, STAND_TICKS);
+}
+/// `PolarBear.getStandingAnimationScale`.
+pub fn standing_scale(m: &Mob, partial: f32) -> f32 {
+    m.anim.lerp(STAND, partial) / STAND_TICKS
+}
+
+/// `PolarBear.tick`: the stand animation, the warning sound's delay and
+/// `NeutralMob.updatePersistentAnger`.
+pub fn ai_step(m: &mut Mob, w: &MobWorld) {
+    client_tick(m);
+    if m.extra.counter > 0 {
+        m.extra.counter -= 1;
+    }
+    if m.ai.target.is_some() {
+        // Anger follows the target and starts over every tick it is held:
+        // 20 to 39 seconds (`PERSISTENT_ANGER_TIME`).
+        m.extra.flag2 = m.ai.target == Some(Who::Player);
+        m.extra.anger = 400 + m.random.next_int_bound(381).unwrap_or(0);
+    } else if m.extra.anger > 0 {
+        m.extra.anger -= 1;
+        if m.extra.anger == 0 {
+            stop_being_angry(m);
+        }
+    }
+    // A player in creative or spectator mode is forgiven at once.
+    if m.extra.flag2 && w.player.as_ref().is_some_and(|p| p.creative || p.spectator) {
+        stop_being_angry(m);
+    }
+}
+/// `NeutralMob.stopBeingAngry`.
+fn stop_being_angry(m: &mut Mob) {
+    m.ai.last_hurt_by = None;
+    m.ai.target = None;
+    m.extra.anger = 0;
+    m.extra.flag2 = false;
+}
diff --git a/crates/horizon-client/src/mobs/rabbit.rs b/crates/horizon-client/src/mobs/rabbit.rs
index a2ab6e95c..ac4c3850f 100644
--- a/crates/horizon-client/src/mobs/rabbit.rs
+++ b/crates/horizon-client/src/mobs/rabbit.rs
@@ -1,5 +1,9 @@
 //! Rabbit hopping controls and the clocks consumed by `RabbitModel`.
-use super::{Mob, MobEvent, MobWorld, control::Operation};
+use super::{
+    Mob, MobEvent, MobWorld,
+    control::Operation,
+    goals::{Breed, Tempt},
+};
 use horizon_core::{
     geometry::{Vec3, trig},
     random::RandomSource,
@@ -14,7 +18,12 @@ const IDLE_TIMEOUT: usize = 3;
 const CLIENT_JUMP_TICKS: usize = 4;
 const CLIENT_JUMP_DURATION: usize = 5;
 
+/// Rabbit.registerGoals after the generic panic and stroll: BreedGoal and
+/// TemptGoal with rabbit food.
 pub fn register(m: &mut Mob) {
+    let food = m.kind.food.clone();
+    m.ai.goals.add(2, Breed::new(0.8));
+    m.ai.goals.add(3, Tempt::new(1.0, food, false));
     m.ai.mov.kind = super::control::MoveKind::Custom;
     m.ai.nav.can_float = true;
     m.extra.ints[IDLE_TIMEOUT] = m.random.next_int_bound(40).unwrap_or(0) + 180;
diff --git a/crates/horizon-client/src/mobs/raider.rs b/crates/horizon-client/src/mobs/raider.rs
index 6c3ab9b64..9b1d17eed 100644
--- a/crates/horizon-client/src/mobs/raider.rs
+++ b/crates/horizon-client/src/mobs/raider.rs
@@ -30,6 +30,9 @@ pub struct State {
     pub celebrating: bool,
     /// The raid is active (`hasActiveRaid`); set by the game every tick.
     pub active_raid: bool,
+    /// A raid is active within 96 blocks (`ServerLevel.isRaided`); set by
+    /// the game every tick for vindicators.
+    pub raided: bool,
     /// The raid is won or lost (`Raid.isOver`), lost (`isLoss`).
     pub raid_over: bool,
     pub raid_loss: bool,
@@ -38,6 +41,11 @@ pub struct State {
     pub in_village: bool,
     /// A dropped ominous banner this raider may fetch.
     pub banner_at: Option<[f64; 3]>,
+    /// The item entity of `banner_at`.
+    pub banner_item: u32,
+    /// Banners with no path to them, and until when (game time):
+    /// `unreachableBannerCache`.
+    pub unreachable_banners: Vec<(u32, i64)>,
     /// Beds around the raid's centre.
     pub homes: Option<std::sync::Arc<Vec<[i32; 3]>>>,
     /// A ravager carrying a raider, set every tick from `Extra::rider`.
@@ -113,7 +121,7 @@ pub fn register(m: &mut Mob) {
     }
     m.extra.raider = Some(Box::default());
     m.ai.goals.add(4, LongDistancePatrol::new(0.7, 0.595));
-    m.ai.goals.add(1, ObtainBanner);
+    m.ai.goals.add(1, ObtainBanner::default());
     m.ai.goals.add(3, PathfindToRaid);
     m.ai.goals.add(4, MoveThroughVillage::new(1.05, 1.0));
     m.ai.goals.add(5, Celebration);
@@ -336,23 +344,37 @@ fn close_to_center(p: [i32; 3], at: Vec3, distance: f64) -> bool {
 
 /// `Raider.ObtainRaidLeaderBannerGoal`: walk to a fallen ominous banner when
 /// the wave has no living leader (the game finds the banner and picks it up).
-#[derive(Clone, Debug)]
-pub struct ObtainBanner;
+#[derive(Clone, Debug, Default)]
+pub struct ObtainBanner {
+    path_to_banner: Option<super::path::Path>,
+}
 impl Goal for ObtainBanner {
     goal_clone!();
     fn flags(&self) -> u8 {
         MOVE
     }
-    fn can_use(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool {
-        state(m).is_some_and(|s| s.banner_at.is_some())
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        let Some((at, item)) = state(m).and_then(|s| s.banner_at.map(|at| (at, s.banner_item)))
+        else {
+            return false;
+        };
+        // A banner with no path to it is skipped for 600 ticks.
+        let path = m.create_path_to_entity(cx.w, at, 1);
+        if path.as_ref().is_some_and(|p| p.reached) {
+            self.path_to_banner = path;
+            return true;
+        }
+        let now = cx.w.game_time;
+        let s = state_mut(m);
+        s.unreachable_banners.retain(|&(_, until)| now < until);
+        s.unreachable_banners.push((item, now + 600));
+        false
     }
     fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool {
         !m.ai.nav.is_done() && state(m).is_some_and(|s| s.banner_at.is_some())
     }
-    fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
-        if let Some(at) = state(m).and_then(|s| s.banner_at) {
-            m.nav_move_to(cx.w, at, 1.15);
-        }
+    fn start(&mut self, m: &mut Mob, _cx: &mut Cx) {
+        m.nav_move_to_path(self.path_to_banner.take(), 1.15);
     }
 }
 
diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs
index 077fd38a6..bbed917a4 100644
--- a/crates/horizon-client/src/mobs/render.rs
+++ b/crates/horizon-client/src/mobs/render.rs
@@ -14,6 +14,12 @@ use std::f32::consts::PI;
 /// A texture lookup into the shared atlas (name without namespace -> uv rect).
 pub type Atlas<'a> = &'a dyn Fn(&str) -> Option<[f32; 4]>;
 
+/// The overlay code of an enchanted armour layer's glint. 7 and 8 are the
+/// item glint and 9 to 12 Horizon's End-portal and breaking overlays, so 13
+/// marks the `ARMOR_ENTITY_GLINT_TEXTURING` sample: entity.wgsl transforms
+/// the model UV and reads `enchanted_glint_armor`.
+pub const ARMOR_GLINT: u32 = 13;
+
 /// One draw of a model with a texture.
 pub struct Layer {
     pub model: String,
@@ -177,8 +183,71 @@ pub fn body(m: &Mob) -> (String, String) {
             "frog#main".into(),
             format!("entity/frog/frog_{}", climate(m)),
         ),
-        S::Rabbit => (
-            baby_or(m, "rabbit#main", "rabbit_baby#main"),
+        // RabbitRenderer.getTextureLocation: the Toast name tag, else the
+        // variant (the killer bunny's id is 99).
+        S::Rabbit => {
+            let name = if m.custom_name.as_deref() == Some("Toast") {
+                "toast"
+            } else {
+                match m.extra.variant {
+                    1 => "white",
+                    2 => "black",
+                    3 => "white_splotched",
+                    4 => "gold",
+                    5 => "salt",
+                    99 => "caerbannog",
+                    _ => "brown",
+                }
+            };
+            (
+                baby_or(m, "rabbit#main", "rabbit_baby#main"),
+                b(&format!("entity/rabbit/rabbit_{name}")),
+            )
+        }
+        // ParrotRenderer.getVariantTexture.
+        S::Parrot => {
+            let name = ["red_blue", "blue", "green", "yellow_blue", "grey"]
+                [usize::from(m.extra.variant).min(4)];
+            (m.kind.model_key(), format!("entity/parrot/parrot_{name}"))
+        }
+        // AxolotlRenderer.getTextureLocation.
+        S::Axolotl => {
+            let name =
+                ["lucy", "wild", "gold", "cyan", "blue"][usize::from(m.extra.variant).min(4)];
+            (
+                baby_or(m, "axolotl#main", "axolotl_baby#main"),
+                b(&format!("entity/axolotl/axolotl_{name}")),
+            )
+        }
+        // SalmonRenderer.submit: the model of the salmon's size.
+        S::Salmon => {
+            let model = match m.extra.variant {
+                0 => "salmon_small#main",
+                2 => "salmon_large#main",
+                _ => "salmon#main",
+            };
+            (model.into(), "entity/fish/salmon".into())
+        }
+        // The baby models and textures of AgeableMobRenderer's other
+        // subclasses.
+        S::Goat => (
+            baby_or(m, "goat#main", "goat_baby#main"),
+            b(&m.kind.texture),
+        ),
+        S::PolarBear => (
+            baby_or(m, "polar_bear#main", "polar_bear_baby#main"),
+            b(&m.kind.texture),
+        ),
+        S::Ocelot => (
+            baby_or(m, "ocelot#main", "ocelot_baby#main"),
+            b(&m.kind.texture),
+        ),
+        S::Turtle => (
+            baby_or(m, "turtle#main", "turtle_baby#main"),
+            b(&m.kind.texture),
+        ),
+        S::Armadillo => (
+            baby_or(m, "armadillo#main", "armadillo_baby#main"),
             b(&m.kind.texture),
         ),
         S::Pig => {
@@ -241,7 +310,7 @@ pub fn body(m: &Mob) -> (String, String) {
         ),
         S::ZombieVillager => (
             baby_or(m, "zombie_villager#main", "zombie_villager_baby#main"),
-            "entity/zombie_villager/zombie_villager".into(),
+            b("entity/zombie_villager/zombie_villager"),
         ),
         S::Villager => (
             baby_or(m, "villager#main", "villager_baby#main"),
@@ -601,14 +670,6 @@ pub fn layers(m: &Mob) -> Vec<Layer> {
             white,
             false,
         ),
-        // EnergySwirlLayer (the scroll is not reproduced: atlas sprites do not wrap).
-        S::Creeper if m.extra.charged => push(
-            &mut v,
-            "creeper#armor",
-            "entity/creeper/creeper_armor",
-            0x80FF_FFFF,
-            true,
-        ),
         S::TropicalFish => {
             // TropicalFishPatternLayer: the pattern tinted with the pattern colour.
             let (model, letter, n) = if m.extra.variant < 6 {
@@ -765,7 +826,14 @@ pub fn base_transform_at(m: &Mob, alpha: f32, origin: glam::Mat4) -> glam::Mat4
     let rotation = match sleep {
         // setupRotations for Pose.SLEEPING, with the head moved toward the pillow.
         Some((angle, step)) => {
-            let head = (m.eye_y() - m.position.y) as f32 - 0.1;
+            // The eye height of the standing pose (LivingEntityRenderer
+            // extracts `getEyeHeight(Pose.STANDING)` for a bed).
+            let eye = if avatar(m) {
+                m.kind.eye_height as f32
+            } else {
+                (m.eye_y() - m.position.y) as f32
+            };
+            let head = eye - 0.1;
             glam::Mat4::from_translation(glam::Vec3::new(-step[0] * head, 0.0, -step[1] * head))
                 * glam::Mat4::from_rotation_y(angle.to_radians())
                 * glam::Mat4::from_rotation_z(90.0_f32.to_radians())
@@ -833,10 +901,15 @@ pub fn base_transform_at(m: &Mob, alpha: f32, origin: glam::Mat4) -> glam::Mat4
     base *= species_scale(m, alpha);
     base * glam::Mat4::from_translation(glam::Vec3::new(0.0, -1.501, 0.0))
 }
-/// `LivingEntityRenderer.isShaking`: converting zombies, piglins and
-/// hoglins, and a zombie villager being cured.
+/// `LivingEntityRenderer.isShaking`: a fully frozen mob (the skeleton's own
+/// `isShaking` is its stray conversion only), converting zombies, piglins
+/// and hoglins, a zombie villager being cured and a cold strider.
 fn shaking(m: &Mob) -> bool {
+    if m.is_fully_frozen() && m.species() != Species::Skeleton {
+        return true;
+    }
     match m.species() {
+        Species::Strider => super::strider::suffocating(m),
         Species::ZombieVillager => super::zombie_villager::is_converting(m),
         Species::Zombie | Species::Husk => m.extra.counter2 > 0,
         Species::Piglin | Species::PiglinBrute | Species::Hoglin => {
@@ -958,6 +1031,13 @@ fn draw_normals(
             let normal = poly.vertex_normal(normals);
             for v in poly.vertices {
                 let pos = m.transform_point3(glam::Vec3::new(v[0], v[1], v[2]) / 16.0);
+                // The armour glint scrolls the layer's model UV in the shader;
+                // the item path already passed its transformed UV.
+                let glint_uv = if overlay == ARMOR_GLINT {
+                    [v[3], v[4]]
+                } else {
+                    [0.0, 0.0]
+                };
                 out.push(Vertex {
                     normal,
                     pos: pos.to_array(),
@@ -968,6 +1048,7 @@ fn draw_normals(
                     layer: overlay,
                     color,
                     light,
+                    glint_uv,
                 });
             }
         }
@@ -1128,9 +1209,9 @@ fn render_visible(
             light
         };
         // EquipmentLayerRenderer draws armour with OverlayTexture.NO_OVERLAY: never
-        // the hurt tint, the glint (7) when enchanted.
+        // the hurt tint, the armour glint (13) when enchanted.
         let overlay = match armor_slot(&layer.model) {
-            Some(slot) if super::gear::enchanted(m, slot) => 7,
+            Some(slot) if super::gear::enchanted(m, slot) => ARMOR_GLINT,
             Some(_) => 0,
             None => overlay,
         };
@@ -1151,10 +1232,50 @@ fn render_visible(
             }
         }
     }
+    // EnergySwirlLayer: the armour model, additive, scrolling over the sprite.
+    if let Some((model, texture, x_offset)) = energy_swirl(m, s.age)
+        && let Some(part) = m.kind.layer(model)
+        && let Some([u0, v0, u1, v1]) = atlas(texture)
+    {
+        layer_poses.reset(part);
+        anim::setup(m, &s, &mut layer_poses, &data.animations);
+        // `RenderTypes.energySwirl`'s texture offset, as the sprite-local UV.
+        let (du, dv) = (x_offset % 1.0, s.age * 0.01 % 1.0);
+        let start = out.len();
+        draw(
+            part,
+            base,
+            &layer_poses,
+            [du, dv, 1.0 + du, 1.0 + dv],
+            crate::breaking::stage_light([u1 - u0, v1 - v0]),
+            crate::breaking::stage_light([u0, v0]),
+            crate::gfx::ENERGY_SWIRL_OVERLAY,
+            out,
+        );
+        // No lighting: the colour bytes carry the sprite's size (fs_energy_swirl).
+        for vertex in &mut out[start..] {
+            vertex.normal = [0; 4];
+        }
+    }
     if shell_last {
         draw_body(out);
     }
 }
+/// `EnergySwirlLayer`'s model, texture and `xOffset(t)` for a charged creeper
+/// (`CreeperPowerLayer`) or a powered wither (`WitherArmorLayer`); `t` is `ageInTicks`.
+fn energy_swirl(m: &Mob, t: f32) -> Option<(&'static str, &'static str, f32)> {
+    match m.species() {
+        Species::Creeper if m.extra.charged => {
+            Some(("creeper#armor", "entity/creeper/creeper_armor", t * 0.01))
+        }
+        Species::Wither if super::wither::powered(m) => Some((
+            "wither#armor",
+            "entity/wither/wither_armor",
+            (t * 0.02).mcos() * 3.0,
+        )),
+        _ => None,
+    }
+}
 /// The equipment slot of a `HumanoidArmorLayer` model (`zombie#helmet`).
 fn armor_slot(model: &str) -> Option<usize> {
     Some(match model.rsplit('#').next()? {
@@ -1235,6 +1356,15 @@ fn hand_base(
         0.0
     };
     let mut t = part_matrix(model, base, poses, arm, offset)?;
+    if m.species() == Species::Vex {
+        // `VexModel.translateToHand`: the held item is drawn at 0.55 scale.
+        t *= glam::Mat4::from_scale(glam::Vec3::splat(0.55));
+        t *= glam::Mat4::from_translation(glam::Vec3::new(
+            if left { -0.046_875 } else { 0.046_875 },
+            -0.156_25,
+            0.078_125,
+        ));
+    }
     let (ox, oy, oz) = if m.is_baby() {
         (0.0, 1.0, -4.5)
     } else {
@@ -1421,4 +1551,40 @@ mod tests {
             assert!(vertices.iter().all(|v| v.uv[0] >= 0.5));
         }
     }
+    /// `VexModel.translateToHand`: the held item is drawn at 0.55 scale and
+    /// moved by the vex's own offset, so the vex's sword is the tiny one
+    /// vanilla shows. It was drawn at the full size, like a zombie's.
+    #[test]
+    fn the_vex_holds_its_item_at_the_small_scale() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client/26.3");
+        if !root.join("entity-models.json").exists() {
+            return;
+        }
+        let types = super::super::MobTypes::load(&root).unwrap();
+        let kind = std::sync::Arc::new(types.types["minecraft:vex"].clone());
+        let mob = Mob::new(1, kind, horizon_core::geometry::Vec3::ZERO, 0.0);
+        let data = MobData {
+            states: Vec::new(),
+            placements: Default::default(),
+            heightmaps: Default::default(),
+            animations: Default::default(),
+            biome_tags: Default::default(),
+            entity_tags: Default::default(),
+            villager_hats: Default::default(),
+            pois: Default::default(),
+        };
+        for left in [false, true] {
+            let t = held_item_transform(&mob, 0.5, glam::DVec3::ZERO, &data, left).unwrap();
+            // The model's own part scale is 1, so the item's scale is the
+            // renderer's: `poseStack.scale(0.55F, 0.55F, 0.55F)`.
+            for axis in [t.x_axis, t.y_axis, t.z_axis] {
+                let scale = axis.truncate().length();
+                assert!(
+                    (scale - 0.55).abs() < 1.0e-5,
+                    "the vex's item is drawn at 0.55 scale, got {scale}"
+                );
+            }
+        }
+    }
 }
diff --git a/crates/horizon-client/src/mobs/shulker.rs b/crates/horizon-client/src/mobs/shulker.rs
index 11ebdadb4..c510409d9 100644
--- a/crates/horizon-client/src/mobs/shulker.rs
+++ b/crates/horizon-client/src/mobs/shulker.rs
@@ -3,8 +3,9 @@
 //! their face is lost or when badly hurt, and shrugging off arrows while
 //! closed.
 use super::{
-    Damage, DamageKind, Mob, MobEvent, MobWorld, Who,
+    Damage, DamageKind, Mob, MobEvent, MobWorld, Species, Who,
     anim::{Poses, State},
+    control::LookKind,
     goals::{
         Cx, Goal, HurtByTarget, LOOK, LookAtPlayer, MOVE, NearestTarget, RandomLookAround,
         goal_clone, reduced,
@@ -14,7 +15,7 @@ use crate::projectiles::{Projectile, ProjectileWorld, STEPS};
 use horizon_core::geometry::trig::Mth;
 use horizon_core::{
     geometry::{Aabb, Vec3},
-    random::RandomSource,
+    random::{LegacyRandom, RandomSource},
 };
 use std::f32::consts::PI;
 
@@ -37,7 +38,13 @@ pub fn register(m: &mut Mob) {
     g.add(4, ShulkerAttack { attack_time: 0 });
     g.add(7, Peek { time: 0 });
     g.add(8, RandomLookAround::default());
-    m.ai.targets.add(1, HurtByTarget::new().alert());
+    // `ShulkerLookControl`: the head turns in the attach face's plane.
+    m.ai.look.kind = LookKind::Shulker;
+    // `HurtByTargetGoal(this, Shulker.class).setAlertOthers()`: damage from
+    // another shulker draws no retaliation (`toIgnoreDamage`), but a hurt
+    // shulker alerts every targetless shulker around.
+    m.ai.targets
+        .add(1, HurtByTarget::new().alert().ignoring(&[Species::Shulker]));
     // ShulkerNearestAttackGoal: the search box is only 4 deep along the
     // attach axis.
     m.ai.targets.add(
@@ -57,6 +64,10 @@ pub fn register(m: &mut Mob) {
 fn face_step(face: u8) -> [i32; 3] {
     STEPS[face.min(5) as usize]
 }
+/// `Direction.getOpposite` for a 3D data value.
+fn opposite(face: u8) -> u8 {
+    face.min(5) ^ 1
+}
 fn block_pos(m: &Mob) -> [i32; 3] {
     [
         m.position.x.floor() as i32,
@@ -64,19 +75,83 @@ fn block_pos(m: &Mob) -> [i32; 3] {
         m.position.z.floor() as i32,
     ]
 }
-/// `Shulker.canStayAt`: an empty spot against a sturdy face.
-fn can_stay_at(w: &MobWorld, p: [i32; 3], face: u8) -> bool {
-    if !w.facts.is_air(w.world.block(p[0], p[1], p[2])) {
+/// `Shulker.getProgressDeltaAabb` at scale 1: the shell's box from `pos`
+/// (the bottom centre), grown `from`..`to` along `direction`.
+fn progress_aabb(direction: u8, from: f64, to: f64, pos: Vec3) -> Aabb {
+    let s = face_step(direction).map(f64::from);
+    let (max, min) = (from.max(to), from.min(to));
+    Aabb::new(Vec3::new(-0.5, 0.0, -0.5), Vec3::new(0.5, 1.0, 0.5))
+        .expand_towards(Vec3::new(s[0] * max, s[1] * max, s[2] * max))
+        .contract(Vec3::new(
+            -s[0] * (1.0 + min),
+            -s[1] * (1.0 + min),
+            -s[2] * (1.0 + min),
+        ))
+        .move_by(pos)
+}
+/// `Level.noCollision(shulker, aabb)`: no block collision under the empty
+/// context, and none of the entities a shulker collides with overlaps
+/// (`canBeCollidedWith`: living shulkers and adult happy ghasts; players
+/// and other mobs never block it).
+fn no_collision(m: &Mob, w: &MobWorld, bounds: Aabb) -> bool {
+    let mut scene = crate::collisions::SceneCollisions {
+        world: w.world,
+        binding: w.collision,
+        subject: None,
+    };
+    if !crate::collisions::no_collision_empty(&mut scene, bounds) {
         return false;
     }
+    let grown = bounds.inflate(Vec3::new(1.0e-7, 1.0e-7, 1.0e-7));
+    !w.others_near(grown).any(|s| {
+        s.id != m.id
+            && s.alive
+            && (s.species == Species::Shulker || (s.species == Species::HappyGhast && !s.baby))
+            && s.bounds.intersects(grown)
+    })
+}
+/// `Shulker.canStayAt`: an empty spot against a sturdy face, with room
+/// for the fully opened shell (`canStayAt`).
+fn can_stay_at(m: &Mob, w: &MobWorld, p: [i32; 3], face: u8) -> bool {
+    // isPositionBlocked: anything but air blocks, except a moving piston
+    // being driven through the shulker's own cell.
+    if !w.facts.is_air(w.world.block(p[0], p[1], p[2]))
+        && (p != block_pos(m) || w.block_name(p[0], p[1], p[2]) != "minecraft:moving_piston")
+    {
+        return false;
+    }
+    // loadedAndEntityCanStandOnFace: the supporting block's face toward
+    // the shell is sturdy.
     let s = face_step(face);
-    let n = w.world.block(p[0] + s[0], p[1] + s[1], p[2] + s[2]);
-    w.facts.get(n).full_collision
+    let support = w.world.block(p[0] + s[0], p[1] + s[1], p[2] + s[2]);
+    let open = opposite(face);
+    if w.facts.get(support).sturdy_full & (1 << open) == 0 {
+        return false;
+    }
+    // The fully opened shell's box, shrunk by the skin vanilla uses.
+    let opened = progress_aabb(
+        open,
+        -1.0,
+        1.0,
+        Vec3::new(
+            f64::from(p[0]) + 0.5,
+            f64::from(p[1]),
+            f64::from(p[2]) + 0.5,
+        ),
+    )
+    .deflate(Vec3::new(1.0e-6, 1.0e-6, 1.0e-6));
+    no_collision(m, w, opened)
 }
 /// `findAttachableSurface`: the first face (down, up, north, south, west,
 /// east) to cling to.
-fn attachable(w: &MobWorld, p: [i32; 3]) -> Option<u8> {
-    (0..6).find(|&f| can_stay_at(w, p, f))
+fn attachable(m: &Mob, w: &MobWorld, p: [i32; 3]) -> Option<u8> {
+    (0..6).find(|&f| can_stay_at(m, w, p, f))
+}
+/// `BlockUtil.packDifferenceInPosition` within 8 blocks of `pos`.
+fn pack_diff(pos: [i32; 3], to: [i32; 3]) -> i32 {
+    ((to[0] - pos[0] + 8) & 0xFF) << 16
+        | ((to[1] - pos[1] + 8) & 0xFF) << 8
+        | (to[2] - pos[2] + 8) & 0xFF
 }
 /// `Shulker.teleportSomewhere`: up to five tries within 8 blocks.
 fn teleport(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) -> bool {
@@ -87,12 +162,31 @@ fn teleport(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) -> bool {
     for _ in 0..5 {
         let r = |m: &mut Mob| m.random.next_int_bound(17).unwrap_or(8) - 8;
         let t = [old[0] + r(m), old[1] + r(m), old[2] + r(m)];
-        if t[1] <= crate::chunk::MIN_Y || !w.facts.is_air(w.world.block(t[0], t[1], t[2])) {
+        let unit = Aabb::new(
+            Vec3::new(f64::from(t[0]), f64::from(t[1]), f64::from(t[2])),
+            Vec3::new(
+                f64::from(t[0]) + 1.0,
+                f64::from(t[1]) + 1.0,
+                f64::from(t[2]) + 1.0,
+            ),
+        );
+        if t[1] <= crate::chunk::MIN_Y
+            || !w.facts.is_air(w.world.block(t[0], t[1], t[2]))
+            || !no_collision(m, w, unit.deflate(Vec3::new(1.0e-6, 1.0e-6, 1.0e-6)))
+        {
             continue;
         }
-        let Some(face) = attachable(w, t) else {
+        let Some(face) = attachable(m, w, t) else {
             continue;
         };
+        // `#minecraft:shulker_does_not_teleport_to` (bedrock) is never clung to.
+        let s = face_step(face);
+        if w.has_tag(
+            "minecraft:shulker_does_not_teleport_to",
+            w.block_name(t[0] + s[0], t[1] + s[1], t[2] + s[2]),
+        ) {
+            continue;
+        }
         m.extra.variant3 = face;
         events.push(MobEvent::Sound(
             "entity.shulker.teleport",
@@ -106,6 +200,14 @@ fn teleport(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) -> bool {
             f64::from(t[2]) + 0.5,
         );
         m.previous = m.position;
+        // Level.levelEvent(2016, oldPos, packedDiff): the teleport's
+        // particles at both ends, seen by the players around.
+        events.push(MobEvent::LevelEvent {
+            id: 2016,
+            pos: old,
+            data: pack_diff(old, t),
+        });
+        m.needs_sync = true;
         m.extra.counter = 0;
         m.ai.target = None;
         return true;
@@ -127,31 +229,109 @@ fn set_peek(m: &mut Mob, amount: i32, events: &mut Vec<MobEvent>) {
     ));
     m.extra.counter = amount;
 }
-/// `Shulker.tick` additions: keep a face (or teleport), ease the peek,
-/// stay still and square on its block.
+/// `Shulker.updatePeekAmount`/`updatePeekAmountO`: the eased peek.
+fn ease_peek(m: &mut Mob) -> (f32, f32) {
+    let old = m.anim.v[PEEK];
+    let target = m.extra.counter as f32 * 0.01;
+    let new = if old > target {
+        (old - 0.05).clamp(target, 1.0)
+    } else {
+        (old + 0.05).clamp(0.0, target)
+    };
+    m.anim.v[PEEK] = new;
+    (old, new)
+}
+/// `Shulker.tick` additions: keep a face (or teleport), ease the peek
+/// (pushing whatever it opens into), stay still and square on its block.
 pub fn tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     m.velocity = Vec3::ZERO;
     m.body_yaw = 0.0;
     m.yaw = 0.0;
     m.head_pitch = 0.0;
     let p = block_pos(m);
-    if !can_stay_at(w, p, m.extra.variant3) {
-        match attachable(w, p) {
+    if !can_stay_at(m, w, p, m.extra.variant3) {
+        match attachable(m, w, p) {
             Some(f) => m.extra.variant3 = f,
             None => {
                 teleport(m, w, events);
             }
         }
     }
-    let a = &mut m.anim;
-    let target = m.extra.counter as f32 * 0.01;
-    let cur = a.v[PEEK];
-    if cur > target {
-        a.v[PEEK] = (cur - 0.05).clamp(target, 1.0);
-    } else if cur < target {
-        a.v[PEEK] = (cur + 0.05).clamp(0.0, target);
+    let (old, new) = ease_peek(m);
+    if new != old {
+        on_peek_change(m, w, old, new, events);
     }
 }
+/// `Shulker.getPhysicalPeek`: the lid's lift for a peek amount.
+fn physical_peek(amount: f32) -> f64 {
+    f64::from(0.5 - ((0.5 + amount) * PI).msin() * 0.5)
+}
+/// `Shulker.onPeekAmountChange`: an opening shell pushes out of its way
+/// every entity that can be collided with (except other shulkers).
+fn on_peek_change(m: &Mob, w: &MobWorld, old: f32, new: f32, events: &mut Vec<MobEvent>) {
+    let dir = opposite(m.extra.variant3);
+    let s = face_step(dir).map(f64::from);
+    let (old_p, new_p) = (physical_peek(old), physical_peek(new));
+    let push = new_p - old_p;
+    if push <= 0.0 {
+        return;
+    }
+    let delta = [push * s[0], push * s[1], push * s[2]];
+    let area = progress_aabb(dir, old_p, new_p, m.position);
+    if let Some(p) = &w.player
+        && p.alive
+        && !p.spectator
+        && p.bounds.intersects(area)
+    {
+        events.push(MobEvent::Shift {
+            target: Who::Player,
+            delta,
+        });
+    }
+    for seen in w.others_near(area) {
+        if seen.id == m.id
+            || !seen.alive
+            || seen.species == Species::Shulker
+            || !seen.bounds.intersects(area)
+        {
+            continue;
+        }
+        events.push(MobEvent::Shift {
+            target: Who::Mob(seen.id),
+            delta,
+        });
+    }
+}
+/// `ShulkerLookControl.getYRotD`: the look yaw in the open direction's
+/// plane (`None`: the target is on the head's own axis).
+pub fn look_yaw(m: &Mob, at: [f64; 3]) -> Option<f32> {
+    let open = opposite(m.extra.variant3);
+    // `attachFace.getRotation().transform(FORWARD)`: the model's forward
+    // rotated as the renderer does (`rotations` uses the same quats).
+    let forward = face_quat(m.extra.variant3) * glam::Vec3::Z;
+    let s = face_step(open).map(|v| v as f32);
+    let right = glam::Vec3::from_array(s).cross(forward);
+    let out = glam::Vec3::new(
+        (at[0] - m.position.x) as f32,
+        (at[1] - m.eye_y()) as f32,
+        (at[2] - m.position.z) as f32,
+    );
+    let (delta_right, delta_forward) = (right.dot(out), forward.dot(out));
+    if delta_right.abs() <= 1.0e-5 && delta_forward.abs() <= 1.0e-5 {
+        return None;
+    }
+    Some(horizon_core::geometry::trig::atan2_degrees(
+        f64::from(-delta_right),
+        f64::from(delta_forward),
+    ))
+}
+/// `Shulker.tick` on a client that is not the server: the lid eases to the
+/// peek it was sent, and its body stays square (`ShulkerBodyRotationControl`).
+pub fn client_tick(m: &mut Mob) {
+    m.anim.vo = m.anim.v;
+    ease_peek(m);
+    m.body_yaw = 0.0;
+}
 /// `Shulker.hurtServer` before the damage: arrows bounce off a closed shell.
 pub fn accepts(m: &Mob, source: &Damage) -> bool {
     !(m.extra.counter == 0 && source.kind == DamageKind::Arrow)
@@ -164,12 +344,62 @@ pub fn after_hurt(m: &mut Mob) {
         m.extra.flag = true;
     }
 }
-/// The deferred teleport of `after_hurt`.
-pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
+/// `Shulker.hurtServer` after a shulker bullet's damage: unless the
+/// low-health teleport was drawn instead (`else if`), `hitByShulkerBullet`
+/// runs on the next tick. Whether the shell is open is read here, at hurt
+/// time, so a goal opening it before that tick cannot change the outcome.
+pub fn hit_by_bullet(m: &mut Mob) {
+    if m.species() == Species::Shulker && !m.extra.flag && m.extra.counter != 0 {
+        m.extra.flag2 = true;
+    }
+}
+/// The deferred teleport of `after_hurt` and `hitByShulkerBullet`.
+pub fn ai_step(
+    m: &mut Mob,
+    w: &MobWorld,
+    level_random: &mut LegacyRandom,
+    events: &mut Vec<MobEvent>,
+) {
     if m.extra.flag {
         m.extra.flag = false;
         teleport(m, w, events);
     }
+    if m.extra.flag2 {
+        m.extra.flag2 = false;
+        hit_by_shulker_bullet(m, w, level_random, events);
+    }
+}
+/// `Shulker.hitByShulkerBullet` (only queued by an open shulker): it
+/// teleports, and leaves a new one of its colour behind unless shulkers
+/// crowd the place (one in five fewer chances for every other shulker
+/// within 8 blocks).
+fn hit_by_shulker_bullet(
+    m: &mut Mob,
+    w: &MobWorld,
+    level_random: &mut LegacyRandom,
+    events: &mut Vec<MobEvent>,
+) {
+    let old_position = m.position;
+    let old_box = m.bounds();
+    if !teleport(m, w, events) {
+        return;
+    }
+    let area = old_box.inflate(Vec3::new(8.0, 8.0, 8.0));
+    // The shulker itself stands within reach of its old box, so it counts.
+    let others = w
+        .others_near(area)
+        .filter(|s| {
+            s.alive && s.species == Species::Shulker && s.id != m.id && s.bounds.intersects(area)
+        })
+        .count();
+    let failure_chance = others as f32 / 5.0;
+    // The level's random, not the shulker's.
+    if level_random.next_float() < failure_chance {
+        return;
+    }
+    let mut baby = Mob::new(0, m.kind.clone(), old_position, 0.0);
+    baby.extra.color = m.extra.color;
+    events.push(MobEvent::Spawn(Box::new(baby)));
 }
 /// A ProjectileWorld over the mob world, for aiming a new bullet.
 struct Probe<'a, 'w> {
@@ -269,7 +499,7 @@ impl Goal for Peek {
     fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
         m.ai.target.is_none()
             && m.random.next_int_bound(reduced(40)).unwrap_or(1) == 0
-            && can_stay_at(cx.w, block_pos(m), m.extra.variant3)
+            && can_stay_at(m, cx.w, block_pos(m), m.extra.variant3)
     }
     fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool {
         m.ai.target.is_none() && self.time > 0
@@ -312,24 +542,27 @@ pub fn texture(m: &Mob) -> String {
         None => "entity/shulker/shulker".into(),
     }
 }
+/// `attachFace.getOpposite().getRotation()` by attach face: the open
+/// direction's rotation (`Direction.getRotation` of `face ^ 1`).
+fn face_quat(face: u8) -> glam::Quat {
+    match face.min(5) {
+        // Attached below: upright.
+        0 => glam::Quat::IDENTITY,
+        1 => glam::Quat::from_rotation_x(PI),
+        2 => glam::Quat::from_rotation_x(PI / 2.0),
+        3 => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, PI),
+        4 => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, -PI / 2.0),
+        _ => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, PI / 2.0),
+    }
+}
 /// `ShulkerRenderer.setupRotations`: turned onto its attach face around the
 /// block's centre (after a half turn of the body).
 pub fn rotations(m: &Mob) -> glam::Mat4 {
-    {
-        let q = match m.extra.variant3 {
-            // Attached below: upright.
-            0 => glam::Quat::IDENTITY,
-            1 => glam::Quat::from_rotation_x(PI),
-            2 => glam::Quat::from_rotation_x(PI / 2.0),
-            3 => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, PI),
-            4 => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, -PI / 2.0),
-            _ => glam::Quat::from_euler(glam::EulerRot::XYZ, PI / 2.0, 0.0, PI / 2.0),
-        };
-        glam::Mat4::from_rotation_y(PI)
-            * glam::Mat4::from_translation(glam::Vec3::new(0.0, 0.5, 0.0))
-            * glam::Mat4::from_quat(q)
-            * glam::Mat4::from_translation(glam::Vec3::new(0.0, -0.5, 0.0))
-    }
+    let q = face_quat(m.extra.variant3);
+    glam::Mat4::from_rotation_y(PI)
+        * glam::Mat4::from_translation(glam::Vec3::new(0.0, 0.5, 0.0))
+        * glam::Mat4::from_quat(q)
+        * glam::Mat4::from_translation(glam::Vec3::new(0.0, -0.5, 0.0))
 }
 /// `ShulkerModel.setupAnim`: the lid rises and twists with the peek, the
 /// head turns.
diff --git a/crates/horizon-client/src/mobs/sniffer.rs b/crates/horizon-client/src/mobs/sniffer.rs
index 6979171b8..72aa76cc2 100644
--- a/crates/horizon-client/src/mobs/sniffer.rs
+++ b/crates/horizon-client/src/mobs/sniffer.rs
@@ -74,6 +74,30 @@ pub fn head_block(m: &Mob) -> [i32; 3] {
 /// the dropped seed and the water malus.
 pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
     use super::path::PathType;
+    let current = state(m);
+    animate(m);
+    if current == DIGGING && now(m) == m.extra.ints[3] {
+        let h = head_block(m);
+        events.push(MobEvent::GiftLoot {
+            mob: m.id,
+            table: "minecraft:gameplay/sniffer_digging",
+            at: [f64::from(h[0]), f64::from(h[1]), f64::from(h[2])],
+        });
+        events.push(MobEvent::Sound(
+            "entity.sniffer.drop_seed",
+            m.center(),
+            1.0,
+            1.0,
+        ));
+    }
+    // The searching sound is the client's (`playSearchingSound`).
+    // onPathfindingStart / Done: water only blocks the way while it is dry.
+    let wet = m.fluids.in_water || m.fire_ticks > 0;
+    m.set_malus(PathType::Water, if wet { 0.0 } else { -1.0 });
+}
+/// `Sniffer.onSyncedDataUpdated(DATA_STATE)`: the animation states of the
+/// state it changed to (on a client, each tick for the state it has).
+pub fn animate(m: &mut Mob) {
     let age = m.age as f32;
     let current = state(m);
     if current != m.extra.scratch[0] as u8 {
@@ -91,23 +115,6 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
         }
         m.extra.scratch[0] = i32::from(current);
     }
-    if current == DIGGING && now(m) == m.extra.ints[3] {
-        let h = head_block(m);
-        events.push(MobEvent::GiftLoot {
-            table: "minecraft:gameplay/sniffer_digging",
-            at: [f64::from(h[0]), f64::from(h[1]), f64::from(h[2])],
-        });
-        events.push(MobEvent::Sound(
-            "entity.sniffer.drop_seed",
-            m.center(),
-            1.0,
-            1.0,
-        ));
-    }
-    // The searching sound is the client's (`playSearchingSound`).
-    // onPathfindingStart / Done: water only blocks the way while it is dry.
-    let wet = m.fluids.in_water || m.fire_ticks > 0;
-    m.set_malus(PathType::Water, if wet { 0.0 } else { -1.0 });
 }
 /// The brain memory holding the explored positions
 /// (`SNIFFER_EXPLORED_POSITIONS`).
diff --git a/crates/horizon-client/src/mobs/spawning.rs b/crates/horizon-client/src/mobs/spawning.rs
index 93e3fe119..3cce491ef 100644
--- a/crates/horizon-client/src/mobs/spawning.rs
+++ b/crates/horizon-client/src/mobs/spawning.rs
@@ -35,8 +35,12 @@ pub fn placement_ok(species: Species, w: &MobWorld, x: i32, y: i32, z: i32) -> b
 #[derive(Clone, Copy, Debug)]
 pub struct LocalDifficulty {
     pub effective: f32,
+    /// The world difficulty is normal.
+    pub normal: bool,
     /// The world difficulty is hard.
     pub hard: bool,
+    /// `Difficulty.getId`: 0 peaceful to 3 hard.
+    pub id: u8,
 }
 /// `DimensionType.MOON_BRIGHTNESS_PER_PHASE`.
 pub const MOON_BRIGHTNESS: [f32; 8] = [1.0, 0.75, 0.5, 0.25, 0.0, 0.25, 0.5, 0.75];
@@ -45,10 +49,13 @@ impl LocalDifficulty {
     /// the overworld clock, the chunk's inhabited time and the moon.
     pub fn new(base: u8, total: i64, inhabited: i64, moon: f32) -> Self {
         let hard = base == 3;
+        let normal = base == 2;
         if base == 0 {
             return Self {
                 effective: 0.0,
+                normal,
                 hard,
+                id: base,
             };
         }
         let global = ((total as f32 - 72000.0) / 1_440_000.0).clamp(0.0, 1.0) * 0.25;
@@ -60,7 +67,9 @@ impl LocalDifficulty {
         }
         Self {
             effective: f32::from(base) * (0.75 + global + local),
+            normal,
             hard,
+            id: base,
         }
     }
     /// `getSpecialMultiplier`.
@@ -148,6 +157,14 @@ pub fn finalize(m: &mut Mob, biome: &BiomeFacts, difficulty: &LocalDifficulty) {
         S::Pig | S::Cow | S::Chicken => m.extra.variant = climate_index,
         S::Sheep => m.extra.color = super::farm::sheep_color(biome.climate, &mut m.random),
         S::Mooshroom => m.extra.variant = 0,
+        // Turtle.finalizeSpawn: home is where it spawned.
+        S::Turtle => {
+            m.extra.home = Some([
+                m.position.x.floor() as i32,
+                m.position.y.floor() as i32,
+                m.position.z.floor() as i32,
+            ])
+        }
         S::Frog => m.extra.variant = biome.frog,
         S::Wolf => m.extra.variant = biome.wolf,
         S::Cat => m.extra.variant = super::tame::cat_variant(m, biome.full_moon),
@@ -158,6 +175,9 @@ pub fn finalize(m: &mut Mob, biome: &BiomeFacts, difficulty: &LocalDifficulty) {
             if m.random.next_float() < 0.05 {
                 m.extra.age = i32::MIN / 2;
             }
+            // setCanBreakDoors(nextFloat() < special * 0.1), before the gear.
+            let can_break_doors = m.random.next_float() < difficulty.special() * 0.1;
+            super::doors::set_can_break_doors(m, can_break_doors);
             if m.species() != S::Drowned {
                 populate_armor(m, difficulty);
             }
@@ -191,6 +211,9 @@ pub fn finalize(m: &mut Mob, biome: &BiomeFacts, difficulty: &LocalDifficulty) {
         // ZombifiedPiglin.populateDefaultEquipmentSlots: a golden sword, or
         // one time in 20 a golden spear.
         S::ZombifiedPiglin => {
+            // Zombie.finalizeSpawn's setCanBreakDoors.
+            let can_break_doors = m.random.next_float() < difficulty.special() * 0.1;
+            super::doors::set_can_break_doors(m, can_break_doors);
             let spear = m.random.next_int_bound(20).unwrap_or(1) == 0;
             m.extra.main_hand = Some(
                 if spear {
@@ -264,6 +287,18 @@ pub fn finalize(m: &mut Mob, biome: &BiomeFacts, difficulty: &LocalDifficulty) {
         S::Slime | S::MagmaCube => super::cube::finalize(m),
         _ => {}
     }
+    // Zombie.finalizeSpawn ends with handleAttributes: the reinforcement
+    // chance (and a leader's bonus) that `Zombie.hurtServer` reads.
+    if matches!(
+        m.species(),
+        S::Zombie | S::Husk | S::Drowned | S::ZombieVillager | S::ZombifiedPiglin
+    ) {
+        super::finalize::zombie_attributes(
+            m,
+            difficulty.special(),
+            super::finalize::Reason::Natural,
+        );
+    }
 }
 /// VillagerType.byBiome
 pub fn villager_type(b: &BiomeFacts) -> u8 {
diff --git a/crates/horizon-client/src/mobs/species.rs b/crates/horizon-client/src/mobs/species.rs
index f48a21fe9..64106574b 100644
--- a/crates/horizon-client/src/mobs/species.rs
+++ b/crates/horizon-client/src/mobs/species.rs
@@ -1447,7 +1447,6 @@ impl Def {
                     | S::IronGolem
                     | S::Cat
                     | S::Ocelot
-                    | S::Frog
                     | S::Slime
                     | S::MagmaCube
                     | S::Wither
@@ -1500,7 +1499,7 @@ impl Def {
                 ),
             // Nautilus.handleAirSupply: it dries out on land.
             needs_water: aquatic || s == S::Nautilus,
-            water_sensitive: matches!(s, S::Enderman | S::Blaze | S::SnowGolem),
+            water_sensitive: matches!(s, S::Enderman | S::Blaze | S::SnowGolem | S::Strider),
             animal: !matches!(s, S::Bat | S::SulfurCube | S::Mannequin)
                 && !self.hostile_class()
                 && !aquatic
@@ -1581,7 +1580,7 @@ impl Def {
             S::Bee => "bee_food",
             S::Turtle => "turtle_food",
             S::Armadillo => "armadillo_food",
-            S::Frog => "frog_food",
+            S::Frog | S::Tadpole => "frog_food",
             S::Axolotl => "axolotl_food",
             S::Hoglin => "hoglin_food",
             S::Strider => "strider_food",
@@ -1629,6 +1628,7 @@ impl Def {
         match self.species {
             Species::Dolphin | Species::Axolotl => 1.0,
             Species::Slime | Species::MagmaCube | Species::SulfurCube => 0.0,
+            Species::Guardian | Species::ElderGuardian | Species::Shulker => 180.0,
             _ => 40.0,
         }
     }
@@ -1640,6 +1640,9 @@ impl Def {
             Species::Sniffer => 50.0,
             Species::Goat => 15.0,
             Species::Armadillo => 32.0,
+            Species::Ravager => 45.0,
+            Species::Camel | Species::CamelHusk => 30.0,
+            Species::Shulker => 180.0,
             _ => 75.0,
         }
     }
@@ -1658,6 +1661,12 @@ impl Def {
             | S::Camel
             | S::CamelHusk => 400,
             S::Ocelot => 900,
+            // Guardian.getAmbientSoundInterval (the elder too).
+            S::Guardian | S::ElderGuardian => 160,
+            // Hoglin extends Animal; Shulker extends AbstractGolem.
+            S::Hoglin | S::Shulker => 120,
+            // Allay is a PathfinderMob: the Mob default.
+            S::Allay => 80,
             S::Squid
             | S::GlowSquid
             | S::Cod
diff --git a/crates/horizon-client/src/mobs/sulfur_cube.rs b/crates/horizon-client/src/mobs/sulfur_cube.rs
index 00b846b86..91c303467 100644
--- a/crates/horizon-client/src/mobs/sulfur_cube.rs
+++ b/crates/horizon-client/src/mobs/sulfur_cube.rs
@@ -297,6 +297,7 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage, amount: f32) -> bool {
             | DamageKind::Fall
             | DamageKind::Sting
             | DamageKind::Cactus
+            | DamageKind::Freeze
     );
     if immune {
         if let Some(from) = source.from {
@@ -370,6 +371,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
         events.push(MobEvent::Explode(
             [m.position.x, m.position.y + 0.0625, m.position.z],
             power,
+            m.species(),
         ));
         m.removed = true;
         return;
diff --git a/crates/horizon-client/src/mobs/sync.rs b/crates/horizon-client/src/mobs/sync.rs
new file mode 100644
index 000000000..d1c5b6609
--- /dev/null
+++ b/crates/horizon-client/src/mobs/sync.rs
@@ -0,0 +1,85 @@
+//! A server's mobs as a client animates them. The server thread, a LAN host
+//! and a dedicated server run each mob's animation state (`ai::tick`); a
+//! client of a server only gets synched data and entity events, and runs the
+//! animation steps vanilla runs on the client (`Entity.onSyncedDataUpdated`,
+//! `handleEntityEvent` and the per tick animation states). The server's half
+//! is `game/lan.rs` (`mob_meta`, with `pose_id` here for index 6) and
+//! `MobEvent::EntityEvent`; the client's half is `game/remote_mob_data.rs`,
+//! `game/remote.rs` (`C::EntityEvent`) and `client_tick` here.
+//!
+//! To animate another species for a client:
+//! - send its synched data in `mob_meta` and read it in
+//!   `remote_mob_data::apply`;
+//! - send its poses in `pose_id` and read them in `set_pose`;
+//! - broadcast its entity events with `MobEvent::EntityEvent` and handle
+//!   them in `entity_event`;
+//! - run its client side animation in `client_tick`, sharing the function
+//!   with the server's `ai_step` where the server computes the same.
+use super::{Mob, Species, breeze, camel, shulker, sniffer, warden};
+
+// `Pose.id` of the poses mobs take.
+pub const STANDING: u8 = 0;
+pub const LONG_JUMPING: u8 = 6;
+pub const SITTING: u8 = 10;
+pub const ROARING: u8 = 11;
+pub const SNIFFING: u8 = 12;
+pub const EMERGING: u8 = 13;
+pub const DIGGING: u8 = 14;
+pub const SLIDING: u8 = 15;
+pub const SHOOTING: u8 = 16;
+pub const INHALING: u8 = 17;
+
+/// `Entity.DATA_POSE` (index 6) of a mob of a server: the pose its species
+/// keeps in its own fields.
+pub fn pose_id(m: &Mob) -> u8 {
+    match m.species() {
+        Species::Warden => warden::pose_id(m),
+        Species::Breeze => breeze::pose_id(m),
+        Species::Camel | Species::CamelHusk if camel::sitting(m) => SITTING,
+        _ => STANDING,
+    }
+}
+
+/// `Entity.onSyncedDataUpdated(DATA_POSE)` on a client.
+pub fn set_pose(m: &mut Mob, id: u8) {
+    m.extra.pose = id;
+    match m.species() {
+        Species::Warden => warden::set_pose_id(m, id),
+        Species::Breeze => breeze::set_pose_id(m, id),
+        _ => {}
+    }
+}
+
+/// The per tick animation steps of a client's mobs (after `m.age` moved on),
+/// for the species whose server runs them in `ai_step`. `game_time` is the
+/// client level's.
+pub fn client_tick(m: &mut Mob, game_time: i64) {
+    match m.species() {
+        Species::Warden => warden::client_tick(m),
+        Species::Sniffer => sniffer::animate(m),
+        Species::Breeze => breeze::ai_step(m),
+        Species::Camel | Species::CamelHusk => camel::client_tick(m, game_time),
+        Species::Shulker => shulker::client_tick(m),
+        _ => {}
+    }
+}
+
+/// `handleEntityEvent` of the mob types that start animations by an event
+/// (`ClientboundEntityEventPacket` for a mob of a client).
+pub fn entity_event(m: &mut Mob, event: u8) {
+    let age = m.age as f32;
+    if m.species() == Species::Warden {
+        match event {
+            // Attack: the roar ends, the swing starts.
+            4 => {
+                m.anim.states[warden::ROAR].stop();
+                m.anim.states[warden::ATTACK].start(age);
+            }
+            // The tendrils twitch.
+            61 => m.anim.v[warden::TENDRIL] = 10.0,
+            // The sonic boom.
+            62 => m.anim.states[warden::SONIC_BOOM].start(age),
+            _ => {}
+        }
+    }
+}
diff --git a/crates/horizon-client/src/mobs/tame.rs b/crates/horizon-client/src/mobs/tame.rs
index 1e725df80..f38296d4b 100644
--- a/crates/horizon-client/src/mobs/tame.rs
+++ b/crates/horizon-client/src/mobs/tame.rs
@@ -2,7 +2,7 @@
 //! sitting, following and defending the owner, begging, anger and shaking
 //! off water (`Wolf`, `WolfModel`).
 use super::{
-    Damage, Mob, MobEvent, MobWorld, Species, Who,
+    Damage, Mob, MobEvent, MobWorld, PlayerView, Species, Who,
     anim::{Poses, State},
     goals::{
         Breed, Cx, Float, Goal, HurtByTarget, JUMP, LOOK, LeapAtTarget, LookAtPlayer, MOVE,
@@ -124,17 +124,23 @@ pub fn set_tame(m: &mut Mob, tame: bool) {
         m.attrs.max_health = 8.0;
     }
 }
-/// The owner (the local player) when tame.
-fn owner(m: &Mob, w: &MobWorld) -> Option<(Vec3, f64, bool)> {
+/// `TamableAnimal.getOwner`: the player the saved owner UUID names, when it
+/// is the one this mob sees; anyone else nearby is not its owner.
+fn owner_view<'a>(m: &Mob, w: &'a MobWorld) -> Option<&'a PlayerView> {
     if !m.extra.tame {
         return None;
     }
     let p = w.player.as_ref()?;
+    (m.extra.owner == Some(p.uuid)).then_some(p)
+}
+/// The owner's position, eye height and spectator flag when tame.
+fn owner(m: &Mob, w: &MobWorld) -> Option<(Vec3, f64, bool)> {
+    let p = owner_view(m, w)?;
     Some((p.position, p.eye[1], p.spectator))
 }
 /// `TamableAnimal.unableToMoveToOwner`.
 fn unable_to_move_to_owner(m: &Mob, w: &MobWorld) -> bool {
-    m.extra.sitting || w.player.as_ref().is_some_and(|p| p.spectator)
+    m.extra.sitting || owner_view(m, w).is_some_and(|p| p.spectator)
 }
 /// `TamableAnimal.tryToTeleportToOwner`: ten tries around the owner.
 fn teleport_to_owner(m: &mut Mob, w: &MobWorld) {
@@ -240,7 +246,7 @@ impl Goal for SitWhenOrdered {
         match owner_distance_sqr(m, cx.w) {
             None => true,
             Some(d) => {
-                let attacked = cx.w.player.as_ref().is_some_and(|p| p.hurt_by.is_some());
+                let attacked = owner_view(m, cx.w).is_some_and(|p| p.hurt_by.is_some());
                 !(d < 144.0 && attacked) && m.extra.sitting
             }
         }
@@ -360,7 +366,7 @@ impl Goal for FollowOwner {
         };
         let far = m.distance_sqr(at) >= 144.0;
         if !far {
-            let max = max_head_x_rot(m);
+            let max = m.max_head_x_rot();
             m.look_at_speed([at.x, eye, at.z], 10.0, max);
         }
         self.recalc -= 1;
@@ -388,7 +394,7 @@ impl Goal for OwnerHurtBy {
         if !m.extra.tame || m.extra.sitting {
             return false;
         }
-        let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.hurt_by) else {
+        let Some((who, at)) = owner_view(m, cx.w).and_then(|p| p.hurt_by) else {
             return false;
         };
         at != self.timestamp && wants_to_attack(m, cx.w, who)
@@ -399,7 +405,7 @@ impl Goal for OwnerHurtBy {
             .is_some_and(|t| t.alive)
     }
     fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
-        if let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.hurt_by) {
+        if let Some((who, at)) = owner_view(m, cx.w).and_then(|p| p.hurt_by) {
             m.ai.target = Some(who);
             self.timestamp = at;
         }
@@ -422,7 +428,7 @@ impl Goal for OwnerHurt {
         if !m.extra.tame || m.extra.sitting {
             return false;
         }
-        let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.last_hurt) else {
+        let Some((who, at)) = owner_view(m, cx.w).and_then(|p| p.last_hurt) else {
             return false;
         };
         at != self.timestamp && wants_to_attack(m, cx.w, who)
@@ -433,7 +439,7 @@ impl Goal for OwnerHurt {
             .is_some_and(|t| t.alive)
     }
     fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
-        if let Some((who, at)) = cx.w.player.as_ref().and_then(|p| p.last_hurt) {
+        if let Some((who, at)) = owner_view(m, cx.w).and_then(|p| p.last_hurt) {
             m.ai.target = Some(who);
             self.timestamp = at;
         }
@@ -507,7 +513,7 @@ impl Goal for Beg {
     }
     fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
         if let Some(p) = &cx.w.player {
-            let max = max_head_x_rot(m);
+            let max = m.max_head_x_rot();
             m.look_at_speed([p.position.x, p.eye[1], p.position.z], 10.0, max);
         }
         self.ticks -= 1;
@@ -529,12 +535,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
     let v = &mut m.anim.v;
     v[INTEREST] += (goal - v[INTEREST]) * 0.4;
     // isWet (extra.flag2), isShaking (counter2 > 0).
-    let rain = w.raining
-        && w.can_see_sky(
-            m.position.x.floor() as i32,
-            (m.position.y + f64::from(m.height())).floor() as i32,
-            m.position.z.floor() as i32,
-        );
+    let rain = super::ai::in_rain(m, w);
     let shaking = m.extra.counter2 > 0;
     if m.fluids.in_water || rain {
         m.extra.flag2 = true;
@@ -683,14 +684,6 @@ pub fn texture(m: &Mob) -> String {
     let baby = if m.is_baby() { "_baby" } else { "" };
     format!("entity/wolf/{file}{state}{baby}")
 }
-/// `Wolf.getMaxHeadXRot`: 20 degrees while sitting.
-fn max_head_x_rot(m: &Mob) -> f32 {
-    if m.extra.sitting {
-        20.0
-    } else {
-        m.kind.max_head_x_rot
-    }
-}
 
 /// Cat variants (`CatVariants`): registry name, texture file.
 pub const CAT_VARIANTS: [&str; 11] = [
@@ -835,7 +828,7 @@ impl Goal for CatLieOnBlock {
         m.extra.flag = self.0.reached;
     }
 }
-/// `CatSitOnBlockGoal`: chests, lit furnaces and beds.
+/// `CatSitOnBlockGoal`: unopened chests, lit furnaces and the foot of beds.
 #[derive(Clone, Debug)]
 struct CatSitOnBlock(super::goals::MoveToBlock);
 fn can_sit_on(w: &MobWorld, p: [i32; 3]) -> bool {
@@ -846,7 +839,15 @@ fn can_sit_on(w: &MobWorld, p: [i32; 3]) -> bool {
     match f.name.as_ref() {
         // The lit state is the only light source a furnace has.
         "minecraft:furnace" => f.emission > 0,
-        _ => true,
+        // `ChestBlockEntity.getOpenCount(level, pos) < 1`: players' openers
+        // and the copper golems' own count.
+        "minecraft:chest" => {
+            let key = (p[0], p[1], p[2]);
+            !w.lid_openers.contains_key(&key)
+                && w.world.chest_openers.get(&key).is_none_or(|o| o.0 < 1)
+        }
+        // A bed's foot only (`BedBlock.PART != HEAD`).
+        _ => w.prop(p[0], p[1], p[2], "part") != Some("head"),
     }
 }
 impl Goal for CatSitOnBlock {
diff --git a/crates/horizon-client/src/mobs/turtle.rs b/crates/horizon-client/src/mobs/turtle.rs
new file mode 100644
index 000000000..e56973384
--- /dev/null
+++ b/crates/horizon-client/src/mobs/turtle.rs
@@ -0,0 +1,399 @@
+//! Turtles (`Turtle`): the egg a bred mother carries (`TurtleBreedGoal`), her
+//! walk home (`TurtleGoHomeGoal`) and the egg she digs into the sand
+//! (`TurtleLayEggGoal`). `extra.flag` is `hasEgg`, `extra.flag2` `isLayingEgg`,
+//! `extra.counter` `layEggCounter` and `extra.home` `homePos`. Its own
+//! `TurtleMoveControl` sets the speed it walks and swims at. Not ported yet:
+//! `Turtle.travelInWater` (swimming still uses the generic fluid travel),
+//! `TurtlePathNavigation` and the rest of the turtle goal set, so movement in
+//! water still differs from vanilla.
+use super::{
+    Mob, MobEvent, MobWorld,
+    control::{EPSILON, Operation, rotlerp},
+    goals::{Breed, Cx, Goal, JUMP, MOVE, MoveToBlock, goal_clone, reduced},
+};
+use horizon_core::{geometry::trig, random::RandomSource};
+
+pub fn register(m: &mut Mob) {
+    let g = &mut m.ai.goals;
+    g.add(1, Breed::new(1.0));
+    g.add(1, LayEgg(MoveToBlock::new(1.0, 16, 1)));
+    g.add(4, GoHome::default());
+}
+/// `Turtle.hasEgg`.
+pub fn has_egg(m: &Mob) -> bool {
+    m.extra.flag
+}
+/// `Turtle.setLayingEgg`.
+fn set_laying_egg(m: &mut Mob, on: bool) {
+    m.extra.counter = i32::from(on);
+    m.extra.flag2 = on;
+}
+/// `homePos.closerToCenterThan(position, distance)`. Spawning, hatching and
+/// loading all set a home; one made any other way is at home where it stands.
+fn close_to_home(m: &Mob, distance: f64) -> bool {
+    let home = m.extra.home.unwrap_or([
+        m.position.x.floor() as i32,
+        m.position.y.floor() as i32,
+        m.position.z.floor() as i32,
+    ]);
+    let d = [
+        f64::from(home[0]) + 0.5 - m.position.x,
+        f64::from(home[1]) + 0.5 - m.position.y,
+        f64::from(home[2]) + 0.5 - m.position.z,
+    ];
+    d[0] * d[0] + d[1] * d[1] + d[2] * d[2] < distance * distance
+}
+fn block_of(m: &Mob) -> [i32; 3] {
+    [
+        m.position.x.floor() as i32,
+        m.position.y.floor() as i32,
+        m.position.z.floor() as i32,
+    ]
+}
+/// `TurtleEggBlock.isSand`.
+fn is_sand(w: &MobWorld, p: [i32; 3]) -> bool {
+    w.has_tag("minecraft:sand", w.block_name(p[0], p[1], p[2]))
+}
+/// `Turtle.TurtleMoveControl.updateSpeed`: slow in water away from home
+/// (slower still as a baby), and halved every tick on land, never under 0.06.
+fn update_speed(m: &mut Mob) {
+    if m.fluids.in_water {
+        m.velocity.y += 0.005;
+        if !close_to_home(m, 16.0) {
+            m.set_speed((m.ai.speed / 2.0).max(0.08));
+        }
+        if m.is_baby() {
+            m.set_speed((m.ai.speed / 3.0).max(0.06));
+        }
+    } else if m.on_ground {
+        m.set_speed((m.ai.speed / 2.0).max(0.06));
+    }
+}
+/// `Turtle.TurtleMoveControl.tick`: ease the speed an eighth of the way to
+/// the wanted one each tick (after `updateSpeed` cut it), face the wanted
+/// point and lift towards it; no jumping, and the operation is never reset.
+pub fn move_control(m: &mut Mob) {
+    update_speed(m);
+    if m.ai.mov.operation != Operation::MoveTo || m.ai.nav.is_done() {
+        m.set_speed(0.0);
+        return;
+    }
+    let [wx, wy, wz] = m.ai.mov.wanted;
+    let (xd, yd, zd) = (wx - m.position.x, wy - m.position.y, wz - m.position.z);
+    let dist = (xd * xd + yd * yd + zd * zd).sqrt();
+    if dist < EPSILON {
+        m.set_speed(0.0);
+        return;
+    }
+    let y_rot = trig::atan2_degrees(zd, xd) - 90.0;
+    m.yaw = rotlerp(m.yaw, y_rot, 90.0);
+    m.body_yaw = m.yaw;
+    let wanted = (m.ai.mov.speed_modifier * m.movement_speed()) as f32;
+    // Mth.lerp(0.125F, getSpeed(), wanted).
+    m.set_speed(m.ai.speed + 0.125 * (wanted - m.ai.speed));
+    m.velocity.y += f64::from(m.ai.speed) * (yd / dist) * 0.1;
+}
+/// `Turtle.aiStep`: while digging, sand crumbs fly every fifth tick.
+pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
+    if m.alive() && m.extra.flag2 && m.extra.counter >= 1 && m.extra.counter % 5 == 0 {
+        let at = block_of(m);
+        let below = [at[0], at[1] - 1, at[2]];
+        if is_sand(w, below) {
+            events.push(MobEvent::BlockBreakEffect {
+                pos: at,
+                block: below,
+            });
+        }
+    }
+}
+
+/// `Turtle.TurtleLayEggGoal`: a mother with an egg within 9 blocks of home
+/// walks to sand with air above, digs for 200 ticks and lays it.
+#[derive(Clone, Debug)]
+struct LayEgg(MoveToBlock);
+impl LayEgg {
+    /// `isValidTarget`: sand with air above it.
+    fn valid(w: &MobWorld, p: [i32; 3]) -> bool {
+        w.facts.is_air(w.world.block(p[0], p[1] + 1, p[2])) && is_sand(w, p)
+    }
+}
+impl Goal for LayEgg {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        MOVE | JUMP
+    }
+    fn name(&self) -> &'static str {
+        "TurtleLayEggGoal"
+    }
+    fn every_tick(&self) -> bool {
+        true
+    }
+    fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        if !(has_egg(m) && close_to_home(m, 9.0)) {
+            return false;
+        }
+        // MoveToBlockGoal.canUse.
+        if self.0.next_start > 0 {
+            self.0.next_start -= 1;
+            return false;
+        }
+        self.0.next_start = reduced(200 + m.random.next_int_bound(200).unwrap_or(0));
+        self.0.find_nearest(m, cx.w, Self::valid)
+    }
+    fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
+        self.0.can_continue(cx.w, Self::valid) && has_egg(m) && close_to_home(m, 9.0)
+    }
+    fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
+        self.0.start(m, cx.w);
+    }
+    fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
+        self.0.tick(m, cx.w);
+        if m.fluids.in_water || !self.0.reached {
+            return;
+        }
+        if m.extra.counter < 1 {
+            set_laying_egg(m, true);
+        } else if m.extra.counter > 200 {
+            let at = [m.position.x, m.position.y, m.position.z];
+            let pitch = 0.9 + m.random.next_float() * 0.2;
+            cx.events
+                .push(MobEvent::Sound("entity.turtle.lay_egg", at, 0.3, pitch));
+            // Blocks.TURTLE_EGG with EGGS = nextInt(4) + 1 above the sand.
+            let eggs = m.random.next_int_bound(4).unwrap_or(0) + 1;
+            let registry = cx.w.registry;
+            let state = registry
+                .default_state("minecraft:turtle_egg")
+                .and_then(|d| registry.state(d).cloned())
+                .and_then(|mut s| {
+                    s.properties.insert("eggs".into(), eggs.to_string());
+                    registry.resolve(&s).ok()
+                });
+            let b = self.0.block;
+            if let Some(state) = state {
+                cx.events.push(MobEvent::SetBlock {
+                    pos: [b[0], b[1] + 1, b[2]],
+                    state,
+                });
+            }
+            m.extra.flag = false;
+            set_laying_egg(m, false);
+            m.extra.in_love = 600;
+        }
+        if m.extra.flag2 {
+            m.extra.counter += 1;
+        }
+    }
+}
+
+/// `Turtle.TurtleGoHomeGoal`: a mother with an egg heads home; any adult
+/// that strayed 64 blocks away does now and then.
+#[derive(Clone, Debug, Default)]
+struct GoHome {
+    stuck: bool,
+    close_to_home_try_ticks: i32,
+}
+impl Goal for GoHome {
+    goal_clone!();
+    fn flags(&self) -> u8 {
+        0
+    }
+    fn name(&self) -> &'static str {
+        "TurtleGoHomeGoal"
+    }
+    fn can_use(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool {
+        if m.is_baby() {
+            false
+        } else if has_egg(m) {
+            true
+        } else {
+            m.random.next_int_bound(reduced(700)).unwrap_or(1) == 0 && !close_to_home(m, 64.0)
+        }
+    }
+    fn start(&mut self, _m: &mut Mob, _cx: &mut Cx) {
+        self.stuck = false;
+        self.close_to_home_try_ticks = 0;
+    }
+    fn can_continue(&mut self, m: &mut Mob, _cx: &mut Cx) -> bool {
+        !close_to_home(m, 7.0) && !self.stuck && self.close_to_home_try_ticks <= reduced(600)
+    }
+    fn tick(&mut self, m: &mut Mob, cx: &mut Cx) {
+        let home = m.extra.home.unwrap_or(block_of(m));
+        let close = close_to_home(m, 16.0);
+        if close {
+            self.close_to_home_try_ticks += 1;
+        }
+        if !m.ai.nav.is_done() {
+            return;
+        }
+        let to = [
+            f64::from(home[0]) + 0.5,
+            f64::from(home[1]),
+            f64::from(home[2]) + 0.5,
+        ];
+        let mut next = m
+            .default_random_pos_towards(cx.w, 16, 3, to, std::f64::consts::PI / 10.0)
+            .or_else(|| m.default_random_pos_towards(cx.w, 8, 7, to, std::f64::consts::FRAC_PI_2));
+        if let Some(at) = next
+            && !close
+            && cx.w.block_name(
+                at[0].floor() as i32,
+                at[1].floor() as i32,
+                at[2].floor() as i32,
+            ) != "minecraft:water"
+        {
+            next = m.default_random_pos_towards(cx.w, 16, 5, to, std::f64::consts::FRAC_PI_2);
+        }
+        match next {
+            Some(at) => {
+                m.nav_move_to(cx.w, at, 1.0);
+            }
+            None => self.stuck = true,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::mobs::{
+        Species,
+        path::{Path, PathNode, PathType},
+    };
+    use horizon_core::geometry::Vec3;
+    use std::sync::Arc;
+
+    /// A turtle (movement speed 0.25) strolling (`speedModifier` 1.0) to a
+    /// point ten blocks ahead along a path it has not finished.
+    fn strolling_turtle() -> Mob {
+        let mut kind = crate::mobs::sensor_scan_tests::kind();
+        let k = Arc::make_mut(&mut kind);
+        k.id = "minecraft:turtle".into();
+        k.species = Species::Turtle;
+        k.speed = 0.25;
+        k.step_height = 1.0;
+        let mut m = Mob::new(1, kind, Vec3::ZERO, 0.0);
+        m.on_ground = true;
+        let node = PathNode {
+            x: 0,
+            y: 0,
+            z: 10,
+            kind: PathType::Walkable,
+        };
+        m.ai.nav.path = Some(Path {
+            nodes: vec![node],
+            next: 0,
+            target: [0, 0, 10],
+            dist_to_target: 0.0,
+            reached: true,
+        });
+        m.ai.mov.set_wanted(0.0, 0.0, 10.0, 1.0);
+        m
+    }
+    fn speeds(m: &mut Mob, ticks: usize) -> Vec<f32> {
+        (0..ticks)
+            .map(|_| {
+                move_control(m);
+                assert_eq!(m.ai.zza, m.ai.speed, "setSpeed sets the forward input");
+                m.ai.speed
+            })
+            .collect()
+    }
+
+    #[test]
+    fn walks_on_land_at_a_third_of_its_movement_speed() {
+        // TurtleMoveControl.tick on the ground: updateSpeed makes it
+        // max(speed / 2, 0.06) = 0.06, then Mth.lerp(0.125F, 0.06, 0.25),
+        // every tick. The default MoveControl walked it at the full 0.25, so
+        // the walk animation (and TurtleModel's 8 * walkSpeed leg swing) ran
+        // about nine times too fast (#1776).
+        let mut m = strolling_turtle();
+        let land = 0.06_f32 + 0.125 * (0.25 - 0.06_f32);
+        assert_eq!(speeds(&mut m, 40), vec![land; 40]);
+        // Facing the wanted point, the body with it; it never jumps.
+        assert_eq!(m.body_yaw, m.yaw);
+        assert!(crate::mobs::living::wrap(m.yaw).abs() < 1.0e-3);
+        assert!(!m.ai.jump);
+        assert_eq!(m.ai.mov.operation, Operation::MoveTo);
+        assert_eq!(m.velocity.y, 0.0);
+    }
+
+    #[test]
+    fn water_speed_is_cut_away_from_home_and_for_babies() {
+        // updateSpeed in water near home: no cut, the lerp climbs towards
+        // 0.25, and it lifts the turtle 0.005 a tick. (Only the control's
+        // speed: Turtle.travelInWater is not ported.)
+        let mut m = strolling_turtle();
+        m.on_ground = false;
+        m.fluids.in_water = true;
+        let s = speeds(&mut m, 60);
+        assert_eq!(s[0], 0.125 * 0.25);
+        assert!(s.windows(2).all(|w| w[1] > w[0]) && s[59] > 0.24 && s[59] < 0.25);
+        assert!((m.velocity.y - 60.0 * 0.005).abs() < 1.0e-9);
+        // More than 16 blocks from home: max(speed / 2, 0.08) first.
+        let mut m = strolling_turtle();
+        m.on_ground = false;
+        m.fluids.in_water = true;
+        m.extra.home = Some([0, 0, 40]);
+        let far = 0.08_f32 + 0.125 * (0.25 - 0.08_f32);
+        assert_eq!(speeds(&mut m, 20), vec![far; 20]);
+        // A baby: max(speed / 3, 0.06).
+        let mut m = strolling_turtle();
+        m.on_ground = false;
+        m.fluids.in_water = true;
+        m.extra.age = -24000;
+        let young = 0.06_f32 + 0.125 * (0.25 - 0.06_f32);
+        assert_eq!(speeds(&mut m, 20), vec![young; 20]);
+    }
+
+    #[test]
+    fn stops_when_the_path_is_done_or_the_point_reached() {
+        let mut m = strolling_turtle();
+        m.ai.nav.stop();
+        assert_eq!(speeds(&mut m, 1), vec![0.0]);
+        let mut m = strolling_turtle();
+        m.ai.mov.set_wanted(0.0, 0.0, 0.0, 1.0);
+        assert_eq!(speeds(&mut m, 1), vec![0.0]);
+        // updateSpeed runs before the early return: a stopped turtle in
+        // water is still lifted 0.005, path done or not moving at all.
+        let mut m = strolling_turtle();
+        m.fluids.in_water = true;
+        m.ai.nav.stop();
+        assert_eq!(speeds(&mut m, 1), vec![0.0]);
+        assert_eq!(m.velocity.y, 0.005);
+        let mut m = strolling_turtle();
+        m.fluids.in_water = true;
+        m.ai.mov.operation = Operation::Wait;
+        assert_eq!(speeds(&mut m, 1), vec![0.0]);
+        assert_eq!(m.velocity.y, 0.005);
+    }
+
+    #[test]
+    fn lifts_towards_a_point_above_by_the_slope_of_the_way_there() {
+        // setDeltaMovement(... + getSpeed() * (dy / dist) * 0.1): two up,
+        // three across and ten ahead.
+        let mut m = strolling_turtle();
+        m.ai.mov.set_wanted(3.0, 2.0, 10.0, 1.0);
+        let speed = speeds(&mut m, 1)[0];
+        let dist = (3.0_f64 * 3.0 + 2.0 * 2.0 + 10.0 * 10.0).sqrt();
+        assert_eq!(m.velocity.y, f64::from(speed) * (2.0 / dist) * 0.1);
+        assert!(m.velocity.y > 0.0);
+    }
+
+    #[test]
+    fn turns_at_most_ninety_degrees_a_tick_and_wraps_into_a_turn() {
+        // rotlerp(yRot, target, 90): from 150 towards about -16.7 it turns
+        // the full 90 to 60, then reaches the target, kept in [0, 360] as
+        // about 343.3; the body follows the yaw each tick.
+        let mut m = strolling_turtle();
+        m.ai.mov.set_wanted(3.0, 0.0, 10.0, 1.0);
+        m.yaw = 150.0;
+        m.body_yaw = 150.0;
+        let target = trig::atan2_degrees(10.0, 3.0) - 90.0;
+        assert!((-17.0..-16.0).contains(&target));
+        move_control(&mut m);
+        assert_eq!((m.yaw, m.body_yaw), (60.0, 60.0));
+        move_control(&mut m);
+        assert_eq!(m.yaw, 60.0 + (target - 60.0) + 360.0);
+        assert_eq!(m.body_yaw, m.yaw);
+    }
+}
diff --git a/crates/horizon-client/src/mobs/undead.rs b/crates/horizon-client/src/mobs/undead.rs
index e77a37641..3707f4bbe 100644
--- a/crates/horizon-client/src/mobs/undead.rs
+++ b/crates/horizon-client/src/mobs/undead.rs
@@ -1,7 +1,8 @@
 //! Zombies (zombie, husk, drowned, zombie villager) and skeletons (skeleton,
 //! stray, bogged, wither skeleton): goals, bow attacks, water conversion.
 use super::{
-    Mob, MobEvent, Species, Who,
+    Damage, Mob, MobEvent, Species, Who,
+    doors::BreakDoor,
     goals::{
         Avoid, AvoidEntity, Cx, FleeSun, Goal, HurtByTarget, LOOK, LookAtPlayer, MOVE, MeleeAttack,
         NearestTarget, RandomLookAround, RestrictSun, Stroll, goal_clone,
@@ -10,11 +11,22 @@ use super::{
 use crate::projectiles::{Projectile, ProjectileKind};
 use horizon_core::{geometry::Vec3, random::RandomSource};
 
+/// `Zombie.hurtServer`, once the hit landed: a zombie with a target (its own,
+/// else a living attacker) asks the game to try calling a reinforcement; the
+/// difficulty, chance and spawn tests are the game's (`call_reinforcements`).
+pub fn after_hurt(m: &mut Mob, source: &Damage) {
+    if let Some(target) = m.ai.target.or(source.attacker) {
+        m.outbox
+            .push(MobEvent::Reinforcements { mob: m.id, target });
+    }
+}
+
 pub fn register(m: &mut Mob) {
     use Species as S;
     match m.species() {
         S::Zombie | S::Husk | S::ZombieVillager => {
             let g = &mut m.ai.goals;
+            g.add(1, BreakDoor::zombie());
             g.add(4, AttackTurtleEgg::default());
             g.add(8, LookAtPlayer::new(8.0));
             g.add(8, RandomLookAround::default());
@@ -42,6 +54,7 @@ pub fn register(m: &mut Mob) {
         S::ZombifiedPiglin => {
             // ZombifiedPiglin.addBehaviourGoals: neutral until provoked.
             let g = &mut m.ai.goals;
+            g.add(1, BreakDoor::zombie());
             g.add(8, LookAtPlayer::new(8.0));
             g.add(8, RandomLookAround::default());
             g.add(2, MeleeAttack::new(1.0, false).zombie());
@@ -58,6 +71,7 @@ pub fn register(m: &mut Mob) {
         S::Drowned => {
             // Zombie.registerGoals, then Drowned.addBehaviourGoals.
             let g = &mut m.ai.goals;
+            g.add(1, BreakDoor::zombie());
             g.add(4, AttackTurtleEgg::default());
             g.add(8, LookAtPlayer::new(8.0));
             g.add(8, RandomLookAround::default());
@@ -136,12 +150,13 @@ pub fn register(m: &mut Mob) {
             }
             // The AbstractSkeleton constructor's reassessWeaponGoal, after
             // registerGoals; the weapon itself comes with finalizeSpawn.
-            let interval = if matches!(species, S::Bogged | S::Parched) {
-                70
+            // getHardAttackInterval / getAttackInterval.
+            let (hard, normal) = if matches!(species, S::Bogged | S::Parched) {
+                (50, 70)
             } else {
-                40
+                (20, 40)
             };
-            m.ai.goals.add(4, SkeletonWeapon::new(interval));
+            m.ai.goals.add(4, SkeletonWeapon::new(hard, normal));
         }
         _ => {}
     }
@@ -217,8 +232,10 @@ pub fn drowned_travel(
     m.velocity = Vec3::new(m.velocity.x * 0.9, m.velocity.y * 0.9, m.velocity.z * 0.9);
     true
 }
-/// The trident throw of `Drowned.performRangedAttack`, until thrown tridents
-/// exist: an arrow-like shot with the trident's damage.
+/// The trident throw of `Drowned.performRangedAttack`: a `ThrownTrident` of
+/// the held trident (a plain one when it holds none), owned by the drowned,
+/// which cannot be picked up and does not return (`AbstractArrow` constructor:
+/// only a player's projectile is `Pickup.ALLOWED`).
 fn drowned_throw(m: &mut Mob, who: Who, _power: f32, cx: &mut Cx) {
     let Some(t) = cx.w.target_info(who) else {
         return;
@@ -228,15 +245,18 @@ fn drowned_throw(m: &mut Mob, who: Who, _power: f32, cx: &mut Cx) {
     let yd = t.position.y + (t.bounds.max_position().y - t.bounds.min_position().y) / 3.0 - start.y;
     let zd = t.position.z - m.position.z;
     let dist = (xd * xd + zd * zd).sqrt();
-    let mut p = Projectile::new(
-        ProjectileKind::Arrow {
-            base_damage: 8.0,
-            critical: false,
-            effect: None,
-        },
-        start,
-        Some(Who::Mob(m.id)),
-    );
+    let mut trident = crate::items::ItemStack::new("minecraft:trident", 1);
+    if m.extra.main_hand.as_deref() == Some("minecraft:trident")
+        && let Some(g) = super::gear::gear(m)
+    {
+        for (e, l) in &g.slots[super::gear::MAIN] {
+            trident.enchant(e, *l);
+        }
+    }
+    let mut p = Projectile::new(ProjectileKind::Trident, start, Some(Who::Mob(m.id)));
+    if let Some(a) = p.arrow.as_mut() {
+        a.set_item(&trident);
+    }
     p.shoot(
         &mut crate::projectiles::own_random(m),
         [xd, yd + dist * f64::from(0.2_f32), zd],
@@ -524,13 +544,20 @@ pub struct SkeletonWeapon {
     bow: BowAttack,
     melee: MeleeAttack,
     use_bow: bool,
+    /// The weapon the goal was last reassessed for.
+    assessed: Option<bool>,
+    hard_interval: i32,
+    normal_interval: i32,
 }
 impl SkeletonWeapon {
-    pub fn new(bow_interval: i32) -> Self {
+    pub fn new(hard_interval: i32, normal_interval: i32) -> Self {
         Self {
-            bow: BowAttack::new(1.0, bow_interval, 15.0),
+            bow: BowAttack::new(1.0, normal_interval, 15.0),
             melee: MeleeAttack::new(1.2, false),
             use_bow: false,
+            assessed: None,
+            hard_interval,
+            normal_interval,
         }
     }
 }
@@ -556,6 +583,18 @@ impl Goal for SkeletonWeapon {
     fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
         // The goal registered for the weapon in hand.
         self.use_bow = holding_bow(m);
+        // reassessWeaponGoal: a bow gets the hard interval only on Hard; it
+        // is picked again when the weapon changes (the first check after
+        // spawning or loading stands for finalizeSpawn and
+        // readAdditionalSaveData).
+        if self.assessed != Some(self.use_bow) {
+            self.assessed = Some(self.use_bow);
+            self.bow.interval_min = if cx.w.difficulty.hard {
+                self.hard_interval
+            } else {
+                self.normal_interval
+            };
+        }
         if self.use_bow {
             self.bow.can_use(m, cx)
         } else {
diff --git a/crates/horizon-client/src/mobs/vex.rs b/crates/horizon-client/src/mobs/vex.rs
index de38f6da8..1301d1922 100644
--- a/crates/horizon-client/src/mobs/vex.rs
+++ b/crates/horizon-client/src/mobs/vex.rs
@@ -29,6 +29,7 @@ pub fn register(m: &mut Mob) {
     g.add(8, RandomMove);
     g.add(9, LookAtPlayer::new(3.0).probability(1.0));
     g.add(10, LookAtPlayer::mobs(8.0));
+    // `HurtByTargetGoal(this, Raider.class)`: raiders are ignored, vexes are not.
     let mut hurt = HurtByTarget::new().alert();
     hurt.ignore = vec![
         Species::Pillager,
@@ -36,7 +37,7 @@ pub fn register(m: &mut Mob) {
         Species::Evoker,
         Species::Illusioner,
         Species::Witch,
-        Species::Vex,
+        Species::Ravager,
     ];
     m.ai.targets.add(1, hurt);
     m.ai.targets.add(2, CopyOwnerTarget);
diff --git a/crates/horizon-client/src/mobs/villager.rs b/crates/horizon-client/src/mobs/villager.rs
index 148034323..20280b190 100644
--- a/crates/horizon-client/src/mobs/villager.rs
+++ b/crates/horizon-client/src/mobs/villager.rs
@@ -448,6 +448,24 @@ impl Ext {
         }
         (stack.count > 0).then_some(stack)
     }
+    /// `SimpleContainer.removeItemType`: take up to `count` of the item from
+    /// the first stacks that hold it.
+    pub fn remove_item(&mut self, item: &str, mut count: u32) {
+        let mut slot = 0;
+        while slot < self.inventory.len() && count > 0 {
+            let s = &mut self.inventory[slot];
+            if &*s.item == item {
+                let n = s.count.min(count);
+                s.count -= n;
+                count -= n;
+                if s.count == 0 {
+                    self.inventory.remove(slot);
+                    continue;
+                }
+            }
+            slot += 1;
+        }
+    }
     pub fn count_item(&self, item: &str) -> u32 {
         self.inventory
             .iter()
@@ -754,30 +772,6 @@ pub fn finalize_summoned_golem(m: &mut Mob, random: &mut impl RandomSource) {
     }
     m.extra.left_handed = random.next_float() < 0.05;
 }
-/// `PoiManager.take(HOME, ..., 48)`: the nearest bed head not `claimed`
-/// (`free_head`: a bed head that is not occupied).
-pub fn take_vacant_bed(
-    claimed: &[[i32; 3]],
-    from: [i32; 3],
-    mut free_head: impl FnMut(i32, i32, i32) -> bool,
-) -> Option<[i32; 3]> {
-    let mut best: Option<(i32, [i32; 3])> = None;
-    for y in from[1] - 8..=from[1] + 8 {
-        for z in from[2] - 48..=from[2] + 48 {
-            for x in from[0] - 48..=from[0] + 48 {
-                let d = (x - from[0]).pow(2) + (y - from[1]).pow(2) + (z - from[2]).pow(2);
-                if d <= 48 * 48
-                    && best.is_none_or(|(b, _)| d < b)
-                    && free_head(x, y, z)
-                    && !claimed.contains(&[x, y, z])
-                {
-                    best = Some((d, [x, y, z]));
-                }
-            }
-        }
-    }
-    best.map(|(_, p)| p)
-}
 /// `Villager.canBreed`: enough food, awake and an adult.
 pub fn can_breed(m: &Mob) -> bool {
     m.species() == Species::Villager
@@ -911,6 +905,53 @@ mod tests {
         assert!(t.unset);
         assert_eq!(m.extra.variant2, 2);
     }
+    /// The reported sequence: a villager works at a bench, the bench is
+    /// destroyed (its job site is gone, so `ResetProfession` makes it
+    /// unemployed) and it takes another bench's job. The new profession's
+    /// trades are offered again.
+    ///
+    /// `Villager.setVillagerData` drops the offers (`offers = null`) when the
+    /// profession changes, so `AbstractVillager.getOffers` rolls the new
+    /// profession's trade set the next time the offers are asked for. A
+    /// villager that keeps its old offers marked as made never trades again:
+    /// it shakes its head instead of opening the trading menu.
+    #[test]
+    fn a_villager_that_loses_its_job_site_offers_its_new_profession_trades() {
+        let mut m = villager();
+        // The composter's job: the villager is a farmer.
+        set_profession(&mut m, 5);
+        assert_eq!(m.extra.variant2, 5);
+        // Its trades were made, so the offers are there.
+        let trade = m.extra.trade.get_or_insert_default();
+        trade.unset = false;
+        trade.offers = vec![crate::merchant::MerchantOffer {
+            base_cost_a: crate::merchant::ItemCost {
+                stack: ItemStack::new("minecraft:wheat", 20),
+            },
+            cost_b: None,
+            result: ItemStack::new("minecraft:emerald", 1),
+            uses: 0,
+            max_uses: 16,
+            reward_exp: true,
+            special_price_diff: 0,
+            demand: 0,
+            price_multiplier: 0.0,
+            xp: 1,
+        }];
+        // The work bench is destroyed: the job site is gone, so the villager
+        // is unemployed and its offers are dropped (`offers = null`).
+        set_profession(&mut m, NONE);
+        let t = m.extra.trade.as_ref().unwrap();
+        assert!(t.offers.is_empty());
+        assert!(t.unset);
+        // It takes the smithing table's job. The new profession's trades are
+        // rolled by the next `getOffers` (ensure_offers).
+        set_profession(&mut m, 13);
+        let t = m.extra.trade.as_ref().unwrap();
+        assert!(t.offers.is_empty());
+        assert!(t.unset);
+        assert_eq!(m.extra.variant2, 13);
+    }
 
     fn stack(item: &str, count: u32) -> ItemStack {
         ItemStack::new(item, count)
diff --git a/crates/horizon-client/src/mobs/villager_brain.rs b/crates/horizon-client/src/mobs/villager_brain.rs
index 7b311a9e0..676d9b713 100644
--- a/crates/horizon-client/src/mobs/villager_brain.rs
+++ b/crates/horizon-client/src/mobs/villager_brain.rs
@@ -789,14 +789,7 @@ pub fn golem_detected(m: &mut Mob, now: i64) {
 
 // ---- Behaviours ---------------------------------------------------------
 
-/// The POI types villagers use.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Poi {
-    /// A job site, by profession index.
-    Job(u8),
-    Home,
-    Meeting,
-}
+pub use crate::poi_sections::Poi;
 impl Poi {
     fn max_tickets(self) -> usize {
         match self {
@@ -1242,6 +1235,8 @@ enum B {
     WorkAtPoi {
         t: Timed,
         last_check: i64,
+        /// `WorkAtComposter` (a farmer's package) rather than `WorkAtPoi`.
+        composter: bool,
     },
     StrollAroundPoi {
         running: bool,
@@ -1635,7 +1630,11 @@ impl B {
                 *birth = now + 275 + i64::from(m.random.next_int_bound(50).unwrap_or(0));
                 true
             }
-            B::WorkAtPoi { t, last_check } => {
+            B::WorkAtPoi {
+                t,
+                last_check,
+                composter,
+            } => {
                 let mm = mem(m);
                 let Some(site) = mm.job_site.value() else {
                     return false;
@@ -1656,6 +1655,13 @@ impl B {
                 mm.last_worked_at_poi.set(now);
                 mm.look_target.set(Tracker::Block(site));
                 play_work_sound(m, cx);
+                // WorkAtComposter.useWorkstation, before the restock.
+                if *composter {
+                    cx.events.push(MobEvent::WorkAtComposter {
+                        mob: m.id,
+                        pos: site,
+                    });
+                }
                 restock_if_due(m, cx.w);
                 true
             }
@@ -2905,11 +2911,18 @@ impl B {
                         let mut bodies = Vec::new();
                         if let Some(t) = cx.w.target_info(target) {
                             let (min, max) = (t.bounds.min_position(), t.bounds.max_position());
-                            bodies.push((t.position, max.x - min.x, max.y - min.y));
+                            bodies.push((partner, t.position, max.x - min.x, max.y - min.y));
                         }
-                        bodies.push((m.position, f64::from(m.width()), f64::from(m.height())));
-                        for (feet, width, height) in bodies {
+                        bodies.push((
+                            m.id,
+                            m.position,
+                            f64::from(m.width()),
+                            f64::from(m.height()),
+                        ));
+                        for (mob, feet, width, height) in bodies {
                             cx.events.push(MobEvent::AroundSelf {
+                                mob,
+                                event: 12,
                                 kind: "heart",
                                 feet: [feet.x, feet.y, feet.z],
                                 width,
@@ -3396,8 +3409,10 @@ fn breeding_possible(m: &mut Mob, w: &MobWorld) -> bool {
         && super::villager::can_breed(m)
         && w.seen(id).is_some_and(|s| s.in_love)
 }
-/// `VillagerMakeLove.takeVacantBed`: a bed head no villager has claimed.
-fn take_bed_for_child(m: &Mob, w: &MobWorld) -> Option<[i32; 3]> {
+/// `VillagerMakeLove.takeVacantBed`: `PoiManager.take(HOME, ..., 48)` over a
+/// sphere of 48 blocks, the nearest bed head no villager has claimed that the
+/// villager can walk to (`canReach`: a path that gets there).
+fn take_bed_for_child(m: &mut Mob, w: &MobWorld) -> Option<[i32; 3]> {
     let claimed: Vec<[i32; 3]> = w
         .others
         .iter()
@@ -3405,10 +3420,20 @@ fn take_bed_for_child(m: &Mob, w: &MobWorld) -> Option<[i32; 3]> {
         .filter_map(|s| s.bed)
         .chain(m.extra.bed)
         .collect();
-    let p = m.position;
-    let from = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32];
-    super::villager::take_vacant_bed(&claimed, from, |x, y, z| {
-        w.prop(x, y, z, "part") == Some("head") && w.prop(x, y, z, "occupied") != Some("true")
+    let from = block_of(m.position);
+    let mut beds: Vec<[i32; 3]> = homes_in_range(m, w, 48)
+        .into_iter()
+        .filter(|p| {
+            w.prop(p[0], p[1], p[2], "part") == Some("head")
+                && w.prop(p[0], p[1], p[2], "occupied") != Some("true")
+                && !claimed.contains(p)
+        })
+        .collect();
+    // Nearest first; equally near beds stay in scan order.
+    beds.sort_by_key(|p| dist_sqr(*p, from));
+    beds.into_iter().find(|&p| {
+        m.create_path_to(w, p, Poi::Home.valid_range())
+            .is_some_and(|path| path.reached)
     })
 }
 /// `BehaviorUtils.lockGazeAndWalkToEachOther`: this villager's half, and
@@ -3580,6 +3605,8 @@ fn pois_scan_order(_m: &Mob, found: &[(Poi, [i32; 3])]) -> Vec<usize> {
 /// `AbstractVillager.addParticlesAroundSelf(HAPPY_VILLAGER)` on the client.
 fn happy_particles(m: &Mob, cx: &mut Bx) {
     cx.events.push(MobEvent::AroundSelf {
+        mob: m.id,
+        event: 14,
         kind: "happy_villager",
         feet: [m.position.x, m.position.y, m.position.z],
         width: f64::from(m.width()),
@@ -3775,6 +3802,7 @@ fn packages(baby: bool, seed: i64, farmer: bool) -> Vec<Entry> {
                         B::WorkAtPoi {
                             t: timed(60, 60),
                             last_check: 0,
+                            composter: farmer,
                         },
                         7,
                     ),
diff --git a/crates/horizon-client/src/mobs/warden.rs b/crates/horizon-client/src/mobs/warden.rs
index 11161ef7c..747443577 100644
--- a/crates/horizon-client/src/mobs/warden.rs
+++ b/crates/horizon-client/src/mobs/warden.rs
@@ -67,6 +67,29 @@ impl Pose {
         }
     }
 }
+/// `Pose.id` of the poses a warden takes (`sync::pose_id`).
+pub fn pose_id(m: &Mob) -> u8 {
+    match pose(m) {
+        Pose::Standing => 0,
+        Pose::Roaring => 11,
+        Pose::Sniffing => 12,
+        Pose::Emerging => 13,
+        Pose::Digging => 14,
+    }
+}
+/// `Entity.onSyncedDataUpdated(DATA_POSE)` on a client.
+pub(super) fn set_pose_id(m: &mut Mob, id: u8) {
+    set_pose(
+        m,
+        match id {
+            11 => Pose::Roaring,
+            12 => Pose::Sniffing,
+            13 => Pose::Emerging,
+            14 => Pose::Digging,
+            _ => Pose::Standing,
+        },
+    );
+}
 /// The warden's pose (kept in `Extra.counter` so it can be read while the
 /// brain is being ticked).
 pub fn pose(m: &Mob) -> Pose {
@@ -434,6 +457,11 @@ pub fn do_push(m: &mut Mob, w: &MobWorld, who: Who, events: &mut Vec<MobEvent>)
 pub(super) fn do_hurt_target(m: &mut Mob, target: Who, w: &MobWorld, events: &mut Vec<MobEvent>) {
     m.anim.states[ROAR].stop();
     m.anim.states[ATTACK].start(m.age as f32);
+    events.push(MobEvent::EntityEvent {
+        mob: m.id,
+        event: 4,
+        at: at(m),
+    });
     let pitch = voice_pitch(m);
     sound(m, "entity.warden.attack_impact", 10.0, pitch, events);
     warden_brain::mem(m).sonic_boom_cooldown.set_ttl((), 40);
@@ -546,6 +574,11 @@ fn receive_vibration(m: &mut Mob, w: &MobWorld, info: Info, events: &mut Vec<Mob
     warden_brain::mem(m).vibration_cooldown.set_ttl((), 40);
     // Entity event 61: the tendrils twitch.
     m.anim.v[TENDRIL] = 10.0;
+    events.push(MobEvent::EntityEvent {
+        mob: m.id,
+        event: 61,
+        at: at(m),
+    });
     let pitch = voice_pitch(m);
     sound(m, "entity.warden.tendril_clicks", 5.0, pitch, events);
     let origin = [
@@ -731,13 +764,7 @@ pub(super) fn tick_sonic_boom(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEve
 /// of the warden: a level event sound here), the tendril and heart
 /// animations, digging crumbs, and keyframes that ended.
 pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
-    let Some(st) = m.extra.warden.as_ref() else {
-        return;
-    };
-    let client_anger = st.client_anger;
-    let delay = heart_beat_delay(client_anger);
-    if i64::from(m.age) % i64::from(delay) == 0 {
-        m.anim.v[HEART] = 10.0;
+    if heartbeat(m) {
         events.push(MobEvent::LevelEventSound {
             sound: "entity.warden.heartbeat",
             at: at(m),
@@ -745,6 +772,30 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
             spread: 0.2,
         });
     }
+    animate(m, events);
+}
+/// The heart's beat on its clock, from the client's anger level: whether
+/// this tick has one (its sound is the caller's).
+fn heartbeat(m: &mut Mob) -> bool {
+    let Some(st) = m.extra.warden.as_ref() else {
+        return false;
+    };
+    let delay = heart_beat_delay(st.client_anger);
+    let beat = i64::from(m.age) % i64::from(delay) == 0;
+    if beat {
+        m.anim.v[HEART] = 10.0;
+    }
+    beat
+}
+/// `Warden.tick` on a client that is not the server: the heart and tendril
+/// animations and the keyframes that ended. Its sounds and particles come
+/// from the server.
+pub fn client_tick(m: &mut Mob) {
+    m.anim.vo = m.anim.v;
+    heartbeat(m);
+    animate(m, &mut Vec::new());
+}
+fn animate(m: &mut Mob, events: &mut Vec<MobEvent>) {
     // The animation values count down after the sync of the last tick.
     for slot in [TENDRIL, HEART] {
         if m.anim.v[slot] > 0.0 {
diff --git a/crates/horizon-client/src/mobs/warden_brain.rs b/crates/horizon-client/src/mobs/warden_brain.rs
index 8caafefc9..667bbedf0 100644
--- a/crates/horizon-client/src/mobs/warden_brain.rs
+++ b/crates/horizon-client/src/mobs/warden_brain.rs
@@ -937,6 +937,11 @@ impl B {
                 mm.sonic_boom_sound_delay.set_ttl((), SONIC_SOUND_DELAY);
                 // Entity event 62: the sonic boom keyframes start.
                 m.anim.states[warden::SONIC_BOOM].start(m.age as f32);
+                cx.events.push(MobEvent::EntityEvent {
+                    mob: m.id,
+                    event: 62,
+                    at: [m.position.x, m.position.y, m.position.z],
+                });
                 sound(m, "entity.warden.sonic_charge", 3.0, 1.0, cx.events);
                 true
             }
diff --git a/crates/horizon-client/src/mobs/witch.rs b/crates/horizon-client/src/mobs/witch.rs
index 0990ae01d..b0ec7866a 100644
--- a/crates/horizon-client/src/mobs/witch.rs
+++ b/crates/horizon-client/src/mobs/witch.rs
@@ -193,6 +193,11 @@ fn witch_attack(m: &mut Mob, who: Who, _power: f32, cx: &mut Cx) {
         }
         Who::Player => false,
     };
+    // `target.hasEffect`: a target that already has the effect gets the next one.
+    let has = |effect: &str| match who {
+        Who::Player => cx.w.player.as_ref().is_some_and(|p| p.has_effect(effect)),
+        Who::Mob(id) => cx.w.seen(id).is_some_and(|s| s.has_effect(effect)),
+    };
     let (effect, ticks, amplifier) = if heals {
         m.ai.target = None;
         if health <= 4.0 {
@@ -200,11 +205,11 @@ fn witch_attack(m: &mut Mob, who: Who, _power: f32, cx: &mut Cx) {
         } else {
             ("minecraft:regeneration", 900, 0)
         }
-    } else if dist >= 8.0 {
+    } else if dist >= 8.0 && !has("slowness") {
         ("minecraft:slowness", 1800, 0)
-    } else if health >= 8.0 {
+    } else if health >= 8.0 && !has("poison") {
         ("minecraft:poison", 900, 0)
-    } else if dist <= 3.0 && m.random.next_float() < 0.25 {
+    } else if dist <= 3.0 && !has("weakness") && m.random.next_float() < 0.25 {
         ("minecraft:weakness", 1800, 0)
     } else {
         ("minecraft:instant_damage", 1, 0)
@@ -236,6 +241,15 @@ fn witch_attack(m: &mut Mob, who: Who, _power: f32, cx: &mut Cx) {
         pitch,
     ));
 }
+/// The movement speed of a witch with `SPEED_MODIFIER_DRINKING` (-0.25,
+/// `ADD_VALUE`) while it drinks: it stands still for the 32 ticks.
+pub fn speed(m: &Mob, base: f64) -> f64 {
+    if m.species() == Species::Witch && m.extra.flag {
+        (base - 0.25).max(0.0)
+    } else {
+        base
+    }
+}
 /// Witch.aiStep before `super.aiStep()`: the healing cooldown, then drink
 /// water breathing, fire resistance, healing or swiftness.
 pub fn ai_step(m: &mut Mob, cx_events: &mut Vec<MobEvent>, target_far: bool) {
diff --git a/crates/horizon-client/src/mobs/wither.rs b/crates/horizon-client/src/mobs/wither.rs
index 6702686c5..2fdd16372 100644
--- a/crates/horizon-client/src/mobs/wither.rs
+++ b/crates/horizon-client/src/mobs/wither.rs
@@ -96,7 +96,7 @@ pub fn make_invulnerable(m: &mut Mob) {
 pub fn powered(m: &Mob) -> bool {
     m.health <= m.attrs.max_health / 2.0
 }
-fn head_pos(m: &Mob, i: usize) -> [f64; 3] {
+pub fn head_pos(m: &Mob, i: usize) -> [f64; 3] {
     if i == 0 {
         return [m.position.x, m.position.y + 3.0, m.position.z];
     }
@@ -221,6 +221,7 @@ pub fn custom_server_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEven
             events.push(MobEvent::Explode(
                 [m.position.x, m.eye_y(), m.position.z],
                 7.0,
+                m.species(),
             ));
             // Global level event 1023.
             if !m.silent {
diff --git a/crates/horizon-client/src/mobs/world.rs b/crates/horizon-client/src/mobs/world.rs
index aa665decc..e1d7b7f8d 100644
--- a/crates/horizon-client/src/mobs/world.rs
+++ b/crates/horizon-client/src/mobs/world.rs
@@ -25,6 +25,8 @@ pub struct TargetInfo {
     pub can_be_seen_as_enemy: bool,
     pub is_player: bool,
     pub creative: bool,
+    /// `isPassenger`.
+    pub passenger: bool,
 }
 impl MobWorld<'_> {
     /// The biome's base temperature at a position.
@@ -206,6 +208,25 @@ impl MobWorld<'_> {
         }
         self.world.light(x, y, z) >> 4 == 15
     }
+    /// Level.precipitationAt: raining, open to the sky, nothing motion
+    /// blocking above, then the biome's precipitation at the position:
+    /// `Some(true)` rain, `Some(false)` snow, `None` nothing.
+    pub fn precipitation_at(&self, x: i32, y: i32, z: i32) -> Option<bool> {
+        if !self.raining || !self.can_see_sky(x, y, z) || self.motion_blocking_height(x, z) > y {
+            return None;
+        }
+        let chunk = self.world.chunks.get(&(x >> 4, z >> 4))?;
+        let biome = self.biomes.get(chunk.biome(x, y, z));
+        if !biome.precipitation {
+            return None;
+        }
+        Some(biome.temperature_at(BlockPos::new(x, y, z), self.sea_level) >= 0.15)
+    }
+    /// Level.isRainingAt: the precipitation at the position is rain, not snow
+    /// or none.
+    pub fn raining_at(&self, x: i32, y: i32, z: i32) -> bool {
+        self.precipitation_at(x, y, z) == Some(true)
+    }
     /// Level.getLightLevelDependentMagicValue: the dimension's brightness curve
     /// at the raw (sky darkened) light level.
     pub fn brightness(&self, x: i32, y: i32, z: i32) -> f32 {
@@ -230,6 +251,7 @@ impl MobWorld<'_> {
                 can_be_seen_as_enemy: true,
                 is_player: true,
                 creative: p.creative,
+                passenger: p.passenger,
             }),
             Who::Mob(id) => self.seen(id).map(|s| TargetInfo {
                 position: s.position,
@@ -239,6 +261,7 @@ impl MobWorld<'_> {
                 can_be_seen_as_enemy: !s.playing_dead,
                 is_player: false,
                 creative: false,
+                passenger: s.passenger,
             }),
         }
     }
diff --git a/crates/horizon-client/src/mod_content_tests.rs b/crates/horizon-client/src/mod_content_tests.rs
index 3d38fae4d..aeeab3016 100644
--- a/crates/horizon-client/src/mod_content_tests.rs
+++ b/crates/horizon-client/src/mod_content_tests.rs
@@ -114,6 +114,7 @@ fn ruby_mod(dir: &Path) -> ContentMod {
 /// new blocks behave like their templates with the overrides, and vanilla's
 /// states are where they were.
 #[test]
+#[ignore = "full content root: CI and pr_ready run it"]
 fn content_root_loads_with_every_table() {
     let Some(base) = prepared() else {
         return;
@@ -352,6 +353,7 @@ fn no_content_keeps_the_base_root() {
 use horizon_world::registry::BlockStateId;
 
 #[test]
+#[ignore = "full content root: CI and pr_ready run it"]
 fn shared_behaviour_document_matches_independent_loaders() {
     let Some(root) = prepared() else { return };
     let assets = Assets::load(&root).expect("assets");
@@ -414,6 +416,7 @@ fn shared_behaviour_document_matches_independent_loaders() {
 
 #[cfg(unix)]
 #[test]
+#[ignore = "full content root: CI and pr_ready run it"]
 fn independent_reloads_read_changed_behaviour_json_and_report_invalid_files() {
     let Some(base) = prepared() else { return };
     let scratch = std::env::temp_dir().join(format!("horizon-json-reloads-{}", std::process::id()));
@@ -535,6 +538,7 @@ fn independent_reloads_read_changed_behaviour_json_and_report_invalid_files() {
 /// A built root is kept for later starts, and built again when a mod's
 /// files change.
 #[test]
+#[ignore = "full content root: CI and pr_ready run it"]
 fn content_root_is_reused_until_a_mod_changes() {
     let Some(base) = prepared() else {
         return;
@@ -571,6 +575,7 @@ fn content_root_is_reused_until_a_mod_changes() {
 /// set, pool and templates join the bundles, and its biome tag keeps only
 /// what the loader knows.
 #[test]
+#[ignore = "full content root: CI and pr_ready run it"]
 fn content_root_carries_a_structure_mod() {
     let Some(base) = prepared() else {
         return;
diff --git a/crates/horizon-client/src/model_library.rs b/crates/horizon-client/src/model_library.rs
index 018bc6af2..5edf0f5a4 100644
--- a/crates/horizon-client/src/model_library.rs
+++ b/crates/horizon-client/src/model_library.rs
@@ -232,18 +232,7 @@ mod tests {
                 .block_library(&fixture.0, vec!["horizon:nested/child".into()])
                 .is_ok()
         );
-        let library = parsed.into_item_library();
-        assert!(library.is_err());
-        fs::write(fixture.0.join("items.json"), "{")?;
-        let load = || {
-            crate::item_render::ItemRenderer::load_with_library(&fixture.0, library.clone())
-                .err()
-                .unwrap()
-                .to_string()
-        };
-        assert!(!load().starts_with("item models:"));
-        fs::write(fixture.0.join("items.json"), "{}")?;
-        assert!(load().starts_with("item models:"));
+        assert!(parsed.into_item_library().is_err());
         Ok(())
     }
 }
diff --git a/crates/horizon-client/src/motion.rs b/crates/horizon-client/src/motion.rs
index fcdd32cbd..0ff3b13c5 100644
--- a/crates/horizon-client/src/motion.rs
+++ b/crates/horizon-client/src/motion.rs
@@ -44,13 +44,19 @@ use std::{
 
 pub(crate) mod environment;
 mod fluids;
-pub use fluids::{FluidResources, FluidTags, LAVA, PlayerFluids, WATER};
+pub use fluids::{FluidResources, FluidTags, LAVA, PlayerFluids, WATER, bubble_column_push};
 
 pub struct MotionResources {
     pub attributes: Arc<Catalog>,
     pub blocks: BoundMovementProperties,
     pub climbable: BTreeSet<String>,
+    /// `BlockTags.CAN_GLIDE_THROUGH`: climbable blocks a gliding player passes.
+    pub glide_through: BTreeSet<String>,
+    /// `BlockTags.SOUL_SPEED_BLOCKS`: what Soul Speed's effects look for.
+    pub soul_speed_blocks: BTreeSet<String>,
     pub fall_reset: BTreeSet<String>,
+    /// `BlockTags.CRYSTAL_SOUND_BLOCKS`: blocks that chime under footsteps.
+    pub crystal_sound: BTreeSet<String>,
     pub landing: BlockLandingRegistry,
     pub health: crate::health::HealthResources,
     pub fluids: FluidResources,
@@ -108,11 +114,31 @@ impl MotionResources {
                 suppresses_bounce: tag("minecraft:suppresses_bounce")?,
             })?,
             climbable: tag("minecraft:climbable")?,
+            glide_through: tag("minecraft:can_glide_through")?,
+            soul_speed_blocks: tag("minecraft:soul_speed_blocks")?,
             fall_reset: tag("minecraft:fall_damage_resetting")?,
+            crystal_sound: tag("minecraft:crystal_sound_blocks")?,
         })
     }
 }
 
+/// What the `location_changed` enchantment effects (Soul Speed) need to know
+/// between ticks.
+#[derive(Clone, Debug, Default)]
+pub struct LocationEffects {
+    /// `MovementAffectedByPredicate`: the block under the player
+    /// (`getBlockPosBelowThatAffectsMyMovement`) is in `#minecraft:soul_speed_blocks`.
+    pub on_soul_speed_block: bool,
+    /// `LivingEntity.lastPos`: the block the player was in last tick.
+    pub block: Option<BlockPos>,
+    /// A landing ran `onChangedBlock` (`LivingEntity.checkFallDamage`).
+    pub landed: bool,
+    /// The Soul Speed level of the boots seen last tick (0: none).
+    pub boots_level: u32,
+    /// The Soul Speed level whose attribute modifiers are on the player (0: none).
+    pub applied_level: u32,
+}
+
 /// Ordered requests and phase records for world/audio/network consumers. Landing
 /// hurt dispatch updates stored health synchronously before these are drained.
 #[derive(Clone, Copy, Debug)]
@@ -142,6 +168,11 @@ pub enum MotionEvent {
         state: BlockStateId,
         in_water: bool,
     },
+    /// `Entity.playAmethystStepSound`: `block.amethyst_block.chime`.
+    Chime {
+        volume: f32,
+        pitch: f32,
+    },
     /// `Entity.waterSwimSound`: `entity.player.swim`.
     Swim {
         volume: f32,
@@ -203,6 +234,14 @@ pub enum MotionEvent {
         bubble: bool,
         position: Vec3,
     },
+    /// `HoneyBlock.maybeDoSlideEffects` for a player sliding down the side of
+    /// the honey block at `pos`: its slide sound, and the server's entity
+    /// event 53 (the five block particles at the player).
+    HoneySlide {
+        pos: BlockPos,
+        sound: bool,
+        particles: bool,
+    },
     /// Entity event 67 (`LivingEntity.makeDrownParticles`): eight bubbles
     /// around a drowning player.
     Drown,
@@ -220,6 +259,9 @@ pub struct PlayerMotion {
     pub history: MovementHistory,
     pub fall_distance: f64,
     pub stuck_multiplier: Vec3,
+    /// `Entity.pistonDeltas` and `pistonDeltasGameTime`: how far a moving
+    /// block has pushed this entity this tick (0.51 at most on any axis).
+    pub piston: horizon_world::piston_movement::PistonMovement,
     pub yaw: f32,
     pub head_yaw: f32,
     pub jumping: bool,
@@ -249,12 +291,16 @@ pub struct PlayerMotion {
     pub pitch: f32,
     /// Gliding (shared flag 7) and LivingEntity.fallFlyTicks.
     pub fall_flying: bool,
+    /// Asleep in a bed (`LivingEntity.isSleeping`): the sleeping pose.
+    pub sleeping: bool,
     pub fall_fly_ticks: i32,
     /// The server saw the glide end last tick (`updateFallFlying`'s `canGlide`
     /// failed): the cleared flag reaches the client at its next tick.
     pub glide_ending: bool,
     /// Glider durability to take this tick (updateFallFlying).
     pub glider_wear: u32,
+    /// Soul Speed's `location_changed` bookkeeping.
+    pub location_effects: LocationEffects,
     /// `LivingEntity.autoSpinAttackTicks` and `autoSpinAttackDmg`: Riptide's
     /// spin. The damage stays until the game has dealt the hit.
     pub auto_spin_attack_ticks: i32,
@@ -276,6 +322,10 @@ pub struct PlayerMotion {
     /// `Entity.moveDist`, `flyDist` and `nextStep`: footsteps come once per
     /// metre walked, not once per move.
     pub steps: MovementDistances,
+    /// `Entity.crystalSoundIntensity` and `lastCrystalSoundPlayTick`: the
+    /// amethyst chime grows with steps taken close together.
+    pub crystal_sound_intensity: f32,
+    pub last_crystal_sound_play_tick: i32,
     pub needs_sync: bool,
     pub sync_position: bool,
     /// Moved by an ender pearl (`ServerPlayer.teleport`): a server sends the
@@ -308,6 +358,9 @@ pub struct PlayerMotion {
     /// it travels on the server: `isLocalInstanceAuthoritative` is false, so
     /// its moves check no fall damage.
     pub server_copy: bool,
+    /// The span of `events` a wall hit on the server's copy pushed (sound and
+    /// damage): `server_travel` keeps them while it drops the simulated moves.
+    pub wall_hit_events: Option<std::ops::Range<usize>>,
     /// A client's copy of its own player (`Level.isClientSide`): only the
     /// server hurts it (`Entity.hurt` does nothing on a client) and ticks its
     /// food (`ServerPlayer.tick`). Its hurt animation comes from the server.
@@ -422,6 +475,7 @@ impl PlayerMotion {
             history: MovementHistory::default(),
             fall_distance: 0.0,
             stuck_multiplier: Vec3::ZERO,
+            piston: Default::default(),
             yaw: 0.0,
             head_yaw: 0.0,
             jumping: false,
@@ -440,9 +494,11 @@ impl PlayerMotion {
             glider: false,
             pitch: 0.0,
             fall_flying: false,
+            sleeping: false,
             fall_fly_ticks: 0,
             glide_ending: false,
             glider_wear: 0,
+            location_effects: LocationEffects::default(),
             auto_spin_attack_ticks: 0,
             auto_spin_attack_dmg: 0.0,
             spin_targets: Vec::new(),
@@ -464,6 +520,8 @@ impl PlayerMotion {
                 next_step: 1.0,
                 ..MovementDistances::default()
             },
+            crystal_sound_intensity: 0.0,
+            last_crystal_sound_play_tick: 0,
             needs_sync: false,
             sync_position: false,
             teleported: false,
@@ -477,6 +535,7 @@ impl PlayerMotion {
             freeze_immune: false,
             old_position: position,
             server_copy: false,
+            wall_hit_events: None,
             client_side: false,
             block_effects: true,
             powder_snow_entered: Vec::new(),
@@ -765,6 +824,10 @@ impl MotionWorld<'_, '_, '_> {
             .state(self.block(p))
             .ok_or("missing scene state")?
             .name;
+        // A gliding player passes through vines (`CAN_GLIDE_THROUGH`).
+        if self.player.fall_flying && self.resources.glide_through.contains(name) {
+            return Ok(false);
+        }
         let climbable = self.resources.climbable.contains(name);
         if climbable {
             self.player.last_climbable = Some(p);
@@ -834,9 +897,17 @@ impl MotionWorld<'_, '_, '_> {
         let can_glide = self.player.glider
             && !self.player.ground.on_ground
             && !self.player.flying
+            && self.player.status.levitation.is_none()
             && !self.player.fluids.was_touching_water
             && !self.player.is_in_lava();
-        if jumping && !toggled && !was_jumping && !self.player.fall_flying && can_glide {
+        // LocalPlayer.aiStep: `!onClimbable()` before tryToStartFallFlying.
+        if jumping
+            && !toggled
+            && !was_jumping
+            && !self.climbable()?
+            && !self.player.fall_flying
+            && can_glide
+        {
             self.player.fall_flying = true;
         }
         // LivingEntity.tick fallFlyTicks, then updateFallFlying.
@@ -848,8 +919,11 @@ impl MotionWorld<'_, '_, '_> {
                 self.player.fall_distance = 1.0;
             }
             self.player.fall_fly_ticks += 1;
-            // canGlide alone: water and lava don't end a glide.
-            let still = self.player.glider && !self.player.ground.on_ground && !self.player.flying;
+            // canGlide alone: water and lava don't end a glide, levitation does.
+            let still = self.player.glider
+                && !self.player.ground.on_ground
+                && !self.player.flying
+                && self.player.status.levitation.is_none();
             if !still {
                 self.player.glide_ending = true;
             } else if (self.player.fall_fly_ticks + 1) % 10 == 0
@@ -984,6 +1058,7 @@ impl MotionWorld<'_, '_, '_> {
             )
         });
         self.player.try_add_frost(on_air)?;
+        self.update_soul_speed_block()?;
         if self.player.health.tick_count % 40 == 0
             && self.player.is_fully_frozen()
             && self.player.can_freeze()
@@ -996,6 +1071,22 @@ impl MotionWorld<'_, '_, '_> {
         }
         Ok(())
     }
+    /// Refresh whether the player stands on a soul speed block, for the
+    /// `location_changed` enchantment effects (a server's player too, whose
+    /// client does the walking).
+    pub fn update_soul_speed_block(&mut self) -> Result<()> {
+        self.player.location_effects.on_soul_speed_block = self.on_soul_speed_block()?;
+        Ok(())
+    }
+    /// `MovementAffectedByPredicate` for `#minecraft:soul_speed_blocks`.
+    fn on_soul_speed_block(&mut self) -> Result<bool> {
+        let on = self.support(movement_support::MOVEMENT_SUPPORT_OFFSET)?;
+        Ok(self
+            .assets
+            .registry
+            .state(self.block(on))
+            .is_some_and(|s| self.resources.soul_speed_blocks.contains(&s.name)))
+    }
     /// Player.travel: swim steering, then LivingEntity.travel (fluids first,
     /// then gliding, then air), keeping 0.6 of the vertical speed while flying.
     fn player_travel(&mut self, input: Vec3) -> Result<()> {
@@ -1021,7 +1112,14 @@ impl MotionWorld<'_, '_, '_> {
         {
             horizon_world::living_fluid::travel_in_fluid(self, input)?;
         } else if self.player.fall_flying {
-            self.travel_fall_flying()?;
+            // LivingEntity.travelFallFlying: on a climbable the glide ends and
+            // the player moves like in the air.
+            if self.climbable()? {
+                self.travel_in_air(input)?;
+                self.player.fall_flying = false;
+            } else {
+                self.travel_fall_flying()?;
+            }
         } else {
             self.travel_in_air(input)?;
         }
@@ -1048,7 +1146,14 @@ impl MotionWorld<'_, '_, '_> {
         p.server_copy = false;
         (p.position, p.ground, p.collision) = (position, ground, collision);
         (p.history, p.fall_distance, p.steps) = (history, fall_distance, steps);
+        // The wall hit is the server's own: its sound and damage events stay.
+        let kept: Vec<_> = p
+            .wall_hit_events
+            .take()
+            .map(|span| p.events.drain(span).collect())
+            .unwrap_or_default();
         p.events.truncate(events);
+        p.events.extend(kept);
         travelled
     }
     /// `LivingEntity.checkAutoSpinAttack`: the first living entity in the
@@ -1373,6 +1478,9 @@ impl MotionWorld<'_, '_, '_> {
                     "minecraft:sweet_berry_bush" if damage_only => {
                         self.sweet_berry_bush_damage(state)?;
                     }
+                    // HoneyBlock.entityInside: a server's player slides too, so
+                    // its fall distance resets (its client moves it).
+                    "minecraft:honey_block" => self.honey_block_inside(p)?,
                     // PowderSnowBlock.entityInside's FREEZE.
                     "minecraft:powder_snow" if damage_only => entered.push((step, p)),
                     _ => {}
@@ -1403,6 +1511,50 @@ impl MotionWorld<'_, '_, '_> {
         }
         Ok(iterations + 1)
     }
+    /// `HoneyBlock.entityInside`: a falling player touching a side of the block
+    /// slides down it (`isSlidingDown`, `doSlideMovement`, `maybeDoSlideEffects`).
+    fn honey_block_inside(&mut self, pos: BlockPos) -> Result<()> {
+        let old_delta_y = |dy: f64| dy / f64::from(0.98_f32) + 0.08;
+        let new_delta_y = |dy: f64| (dy - 0.08) * f64::from(0.98_f32);
+        let position = self.player.position;
+        let velocity = self.player.velocity;
+        if self.player.ground.on_ground
+            || position.y > f64::from(pos.y) + 0.9375 - 1.0e-7
+            || old_delta_y(velocity.y) >= -0.08
+        {
+            return Ok(());
+        }
+        let dx = (f64::from(pos.x) + 0.5 - position.x).abs();
+        let dz = (f64::from(pos.z) + 0.5 - position.z).abs();
+        let overlap = 0.4375 + f64::from(self.player.dimensions.width / 2.0);
+        if !(dx + 1.0e-7 > overlap || dz + 1.0e-7 > overlap) {
+            return Ok(());
+        }
+        // doSlideMovement
+        let old = old_delta_y(velocity.y);
+        if old < -0.13 {
+            let factor = -0.05 / old;
+            self.player.velocity =
+                Vec3::new(velocity.x * factor, new_delta_y(-0.05), velocity.z * factor);
+        } else {
+            self.player.velocity = Vec3::new(velocity.x, new_delta_y(-0.05), velocity.z);
+        }
+        self.player.fall_distance = 0.0;
+        // maybeDoSlideEffects: the sound, then the server's event 53.
+        let random = &mut self.scene.random;
+        let sound = random.next_int_bound(5).map_err(|e| format!("{e:?}"))? == 0;
+        // Only the server broadcasts event 53 (`!level.isClientSide()`).
+        let particles = !self.player.client_side
+            && random.next_int_bound(5).map_err(|e| format!("{e:?}"))? == 0;
+        if sound || particles {
+            self.player.events.push(MotionEvent::HoneySlide {
+                pos,
+                sound,
+                particles,
+            });
+        }
+        Ok(())
+    }
     /// `Player.makeStuckInBlock`: the next move is scaled by `multiplier`
     /// (and the fall forgotten) unless flying; the impulse context resets
     /// either way.
@@ -1536,7 +1688,7 @@ impl MotionWorld<'_, '_, '_> {
         let lean = pitch;
         let look_h = (look.x * look.x + look.z * look.z).sqrt();
         let move_h = (v.x * v.x + v.z * v.z).sqrt();
-        let gravity = 0.08;
+        let gravity = living_motion::effective_gravity(self)?;
         let lift = f64::from(lean.cos()).powi(2);
         let mut m = Vec3::new(v.x, v.y + gravity * (-1.0 + lift * 0.75), v.z);
         if m.y < 0.0 && look_h > 0.0 {
@@ -1564,7 +1716,44 @@ impl MotionWorld<'_, '_, '_> {
         }
         self.player.velocity = Vec3::new(m.x * 0.99, m.y * 0.98, m.z * 0.99);
         let movement = self.player.velocity;
-        self.move_self(movement)
+        self.move_self(movement)?;
+        // LivingEntity.handleFallFlyingCollisions: only the server hurts.
+        if !self.player.client_side && self.player.collision.horizontal {
+            let new_h = {
+                let v = self.player.velocity;
+                (v.x * v.x + v.z * v.z).sqrt()
+            };
+            let dmg = ((move_h - new_h) * 10.0 - 3.0) as f32;
+            if dmg > 0.0 {
+                let first = self.player.events.len();
+                // getFallDamageSound((int) dmg)
+                let sound = if dmg as i32 > 4 {
+                    crate::landing::SceneSound::BigFall
+                } else {
+                    crate::landing::SceneSound::SmallFall
+                };
+                self.player
+                    .events
+                    .push(MotionEvent::Fall(crate::landing::FallEvent::Sound {
+                        sound,
+                        position: None,
+                        volume: 1.0,
+                        pitch: 1.0,
+                    }));
+                let id = self
+                    .resources
+                    .health
+                    .damage
+                    .id("minecraft:fly_into_wall")
+                    .ok_or("missing fly_into_wall damage type")?;
+                let rules = self.scene.health_rules;
+                self.player.hurt(&self.resources.health, rules, id, dmg)?;
+                if self.player.server_copy {
+                    self.player.wall_hit_events = Some(first..self.player.events.len());
+                }
+            }
+        }
+        Ok(())
     }
     /// `LocalPlayer.move`: the move, then `updateAutoJump` with the float
     /// horizontal displacement.
@@ -1722,8 +1911,14 @@ impl EntityMoveWorld for MotionWorld<'_, '_, '_> {
     fn set_collision_flags(&mut self, value: CollisionFlags) {
         self.player.collision = value;
     }
-    fn limit_piston_movement(&mut self, _: Vec3) -> Result<Vec3> {
-        Err("piston movement requires a ticking entity runtime".into())
+    /// `Entity.limitPistonMovement`: the per-tick 0.51-block budget shared by
+    /// every move on an axis. A failed game-time read leaves the accumulator
+    /// as it was, as native does.
+    fn limit_piston_movement(&mut self, movement: Vec3) -> Result<Vec3> {
+        let time = self.scene.game_time;
+        self.player
+            .piston
+            .limit(movement, || Ok::<i64, Box<dyn std::error::Error>>(time))
     }
     fn stuck_multiplier(&self) -> Vec3 {
         self.player.stuck_multiplier
@@ -1842,6 +2037,10 @@ impl EntityMoveWorld for MotionWorld<'_, '_, '_> {
         if self.player.status.slow_falling || self.player.status.levitation.is_some() {
             self.player.fall_distance = 0.0;
         }
+        // LivingEntity.checkFallDamage: a landing runs onChangedBlock.
+        if grounded && self.player.fall_distance > 0.0 {
+            self.player.location_effects.landed = true;
+        }
         if self.player.spawn_extra_particles_on_fall && grounded && self.player.fall_distance > 0.0
         {
             self.player.events.push(MotionEvent::SmashLanding {
@@ -1992,6 +2191,30 @@ impl MovementEmissionWorld for MotionWorld<'_, '_, '_> {
             state,
             in_water,
         });
+        // Entity.walkingStepSound: the amethyst chime after the step.
+        let name = &self
+            .assets
+            .registry
+            .state(state)
+            .ok_or("missing scene state")?
+            .name;
+        let tick = self.player.health.tick_count;
+        if self.resources.crystal_sound.contains(name)
+            && tick >= self.player.last_crystal_sound_play_tick + 20
+        {
+            // Entity.playAmethystStepSound (the level random stands in for
+            // the entity's).
+            let elapsed = f64::from(tick - self.player.last_crystal_sound_play_tick);
+            let decayed = self.player.crystal_sound_intensity * 0.997_f64.powf(elapsed) as f32;
+            let intensity = 1.0_f32.min(decayed + 0.07);
+            self.player.crystal_sound_intensity = intensity;
+            let pitch = 0.5 + intensity * self.scene.random.next_float() * 1.2;
+            let volume = 0.1 + intensity * 1.2;
+            self.player
+                .events
+                .push(MotionEvent::Chime { volume, pitch });
+            self.player.last_crystal_sound_play_tick = tick;
+        }
         Ok(())
     }
     fn step_event(&mut self, _: BlockStateId) -> Result<()> {
@@ -3871,4 +4094,190 @@ mod tests {
             "{walked} steps over {metres} step-metres"
         );
     }
+    /// Vanilla sprint is a state, not a held key: `LocalPlayer.aiStep` starts
+    /// it with the sprint key and stops it only on a vanilla stop condition.
+    /// Releasing the key while swimming keeps the sprint and its swim speed.
+    #[test]
+    fn a_sprint_survives_the_sprint_key_coming_up_while_swimming() {
+        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("movement-properties.nbt").exists() {
+            return;
+        }
+        let assets = Assets::load(&root).unwrap();
+        let render = assets.reload(&root).unwrap();
+        let binding = crate::collisions::load(&root, assets.registry).unwrap();
+        let resources = MotionResources::load(&root, &assets).unwrap();
+        let water = assets.registry.default_state("minecraft:water").unwrap();
+        let forward = crate::sprint::Keys {
+            forward: true,
+            ..Default::default()
+        };
+        let sprinting = crate::sprint::Keys {
+            sprint: true,
+            ..forward
+        };
+        // The same swim with the sprint key held, and with the key released
+        // once the sprint has started: the speed must not change.
+        let mut swims = Vec::new();
+        for release in [false, true] {
+            let mut scene = World::test_scene(&assets, &render, 3).unwrap();
+            for x in 19..=21 {
+                for y in 4..=8 {
+                    for z in 19..=31 {
+                        scene.set(x, y, z, water).unwrap();
+                    }
+                }
+            }
+            let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
+            let mut w = MotionWorld {
+                entities: &[],
+                player: &mut player,
+                scene: &mut scene,
+                assets: &assets,
+                collision_binding: &binding,
+                resources: &resources,
+            };
+            let mut speed = Vec::new();
+            for tick in 0..12 {
+                // The key comes up on the fourth tick, after the sprint has
+                // started and the player swims.
+                let keys = if release && tick >= 4 {
+                    forward
+                } else {
+                    sprinting
+                };
+                w.controlled_simulation_tick(keys).unwrap();
+                speed.push(w.player.velocity.z);
+            }
+            assert!(
+                w.player.sprinting,
+                "the sprint state survives the sprint key in water"
+            );
+            assert!(w.player.swimming, "a sprinting player in water swims");
+            swims.push(speed);
+        }
+        assert_eq!(
+            swims[0], swims[1],
+            "the swim speed must not drop when the sprint key comes up"
+        );
+    }
+
+    /// Vanilla: `LivingEntity.jumpFromGround` adds its 0.2 forward impulse
+    /// while the sprint state holds, so a jump taken after the sprint key
+    /// comes up is still a sprint jump.
+    #[test]
+    fn a_sprint_jump_keeps_its_impulse_when_the_sprint_key_comes_up() {
+        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("movement-properties.nbt").exists() {
+            return;
+        }
+        let assets = Assets::load(&root).unwrap();
+        let render = assets.reload(&root).unwrap();
+        let binding = crate::collisions::load(&root, assets.registry).unwrap();
+        let resources = MotionResources::load(&root, &assets).unwrap();
+        let mut scene = World::test_scene(&assets, &render, 3).unwrap();
+        let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
+        let mut w = MotionWorld {
+            entities: &[],
+            player: &mut player,
+            scene: &mut scene,
+            assets: &assets,
+            collision_binding: &binding,
+            resources: &resources,
+        };
+        let forward = crate::sprint::Keys {
+            forward: true,
+            ..Default::default()
+        };
+        let sprinting = crate::sprint::Keys {
+            sprint: true,
+            ..forward
+        };
+        for _ in 0..20 {
+            w.controlled_simulation_tick(sprinting).unwrap();
+        }
+        assert!(w.player.ground.on_ground, "the player settles on the floor");
+        assert!(w.player.sprinting, "the sprint key starts the sprint");
+        let running = w.player.velocity.z;
+        // The sprint key comes up and the player jumps.
+        w.controlled_simulation_tick(crate::sprint::Keys {
+            jump: true,
+            ..forward
+        })
+        .unwrap();
+        assert!(
+            w.player.sprinting,
+            "the sprint state survives the sprint key in the air"
+        );
+        assert!(
+            w.player.velocity.z > running + 0.05,
+            "the sprint jump keeps its forward impulse: {:?} vs {running}",
+            w.player.velocity
+        );
+    }
+
+    /// Vanilla `Player.getFlyingSpeed`: a flying player moves at the ability
+    /// speed, doubled while the sprint state holds. The sprint key starts the
+    /// state; releasing it does not change the speed.
+    #[test]
+    fn the_flight_speed_follows_the_sprint_state_not_the_sprint_key() {
+        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("movement-properties.nbt").exists() {
+            return;
+        }
+        let assets = Assets::load(&root).unwrap();
+        let render = assets.reload(&root).unwrap();
+        let binding = crate::collisions::load(&root, assets.registry).unwrap();
+        let resources = MotionResources::load(&root, &assets).unwrap();
+        let mut scene = World::test_scene(&assets, &render, 3).unwrap();
+        let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 10.0, 20.5)).unwrap();
+        let mut w = MotionWorld {
+            entities: &[],
+            player: &mut player,
+            scene: &mut scene,
+            assets: &assets,
+            collision_binding: &binding,
+            resources: &resources,
+        };
+        w.player.may_fly = true;
+        w.player.flying = true;
+        let forward = crate::sprint::Keys {
+            forward: true,
+            ..Default::default()
+        };
+        let sprinting = crate::sprint::Keys {
+            sprint: true,
+            ..forward
+        };
+        assert_eq!(
+            w.flying_speed().unwrap(),
+            0.05,
+            "a flying player without a sprint moves at the ability speed"
+        );
+        // The sprint key starts the sprint, and the state doubles the speed.
+        w.controlled_simulation_tick(sprinting).unwrap();
+        assert!(w.player.sprinting, "the sprint key starts the sprint");
+        assert_eq!(
+            w.flying_speed().unwrap(),
+            0.1,
+            "a sprinting player flies at twice the ability speed"
+        );
+        // Releasing the sprint key keeps the state, so the speed stays.
+        w.controlled_simulation_tick(forward).unwrap();
+        assert!(
+            w.player.sprinting,
+            "the sprint state survives the sprint key in the air"
+        );
+        assert_eq!(
+            w.flying_speed().unwrap(),
+            0.1,
+            "the flight speed follows the sprint state, not the sprint key"
+        );
+    }
 }
diff --git a/crates/horizon-client/src/motion/environment.rs b/crates/horizon-client/src/motion/environment.rs
index fc3c63c77..5e9bdfec8 100644
--- a/crates/horizon-client/src/motion/environment.rs
+++ b/crates/horizon-client/src/motion/environment.rs
@@ -161,6 +161,29 @@ pub(crate) fn fire_contact(
     }
     damage
 }
+/// `CactusBlock.entityInside`: the box (deflated by `1.0E-5`, as in
+/// `Entity.checkInsideBlocks`) touches a cactus; its inside shape is the
+/// whole block.
+pub(crate) fn cactus_contact(
+    world: &World,
+    registry: &horizon_world::registry::BlockRegistry,
+    bounds: Aabb,
+) -> bool {
+    let b = bounds.deflate(Vec3::new(1e-5, 1e-5, 1e-5));
+    for x in b.min_position().x.floor() as i32..=b.max_position().x.floor() as i32 {
+        for y in b.min_position().y.floor() as i32..=b.max_position().y.floor() as i32 {
+            for z in b.min_position().z.floor() as i32..=b.max_position().z.floor() as i32 {
+                if registry
+                    .state(world.block(x, y, z))
+                    .is_some_and(|s| s.name == "minecraft:cactus")
+                {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}
 impl LivingFluidWorld for MotionWorld<'_, '_, '_> {
     fn in_water(&mut self) -> Result<bool> {
         Ok(self.player.fluids.was_touching_water)
diff --git a/crates/horizon-client/src/motion/fluids.rs b/crates/horizon-client/src/motion/fluids.rs
index 894e6d907..e3751f0c6 100644
--- a/crates/horizon-client/src/motion/fluids.rs
+++ b/crates/horizon-client/src/motion/fluids.rs
@@ -119,6 +119,67 @@ impl PlayerMotion {
         !self.fluids.first_tick && self.fluids.interaction.is_in_fluid(&FluidTags, LAVA)
     }
 }
+/// `BubbleColumnBlock.entityInside` for an entity that is not the player (a mob,
+/// a dropped item, an ender pearl): the bubble columns its box touches push it
+/// up or drag it down, harder at the surface (`Entity.handleOnAboveBubbleColumn`
+/// and `handleOnInsideBubbleColumn`). Returns whether it was inside a column
+/// below the surface, which resets its fall distance.
+pub fn bubble_column_push(
+    world: &World,
+    registry: &horizon_world::registry::BlockRegistry,
+    facts: &crate::blocks::BlockFacts,
+    collision: &horizon_world::block_collision::BlockCollisionRegistry<'_>,
+    bounds: Aabb,
+    velocity: &mut Vec3,
+) -> bool {
+    let b = bounds.deflate(Vec3::new(
+        f64::from(1.0e-5f32),
+        f64::from(1.0e-5f32),
+        f64::from(1.0e-5f32),
+    ));
+    let (lo, hi) = (b.min_position(), b.max_position());
+    let mut reset_fall = false;
+    for x in lo.x.floor() as i32..=(hi.x.ceil() as i32 - 1) {
+        for y in lo.y.floor() as i32..=(hi.y.ceil() as i32 - 1) {
+            for z in lo.z.floor() as i32..=(hi.z.ceil() as i32 - 1) {
+                let state = world.block(x, y, z);
+                if &*facts.get(state).name != "minecraft:bubble_column" {
+                    continue;
+                }
+                let drag = registry
+                    .state(state)
+                    .and_then(|s| s.properties.get("drag"))
+                    .is_some_and(|d| d == "true");
+                let above = world.block(x, y + 1, z);
+                // stateAbove.getCollisionShape(level, pos): the shape is asked
+                // at the column's own position.
+                let mut scene = SceneCollisions {
+                    world,
+                    binding: collision,
+                    subject: None,
+                };
+                let context = horizon_world::collision_context::CollisionContext::empty(false);
+                let nothing_above = collision
+                    .collision_shape_with_context(
+                        &mut scene,
+                        above,
+                        BlockPos::new(x, y, z),
+                        &context,
+                    )
+                    .is_ok_and(|shape| shape.is_empty())
+                    && facts.get(above).fluid == crate::blocks::Fluid::None;
+                velocity.y = match (nothing_above, drag) {
+                    (true, true) => (-0.9_f64).max(velocity.y - 0.03),
+                    (true, false) => 1.8_f64.min(velocity.y + 0.1),
+                    (false, true) => (-0.3_f64).max(velocity.y - 0.03),
+                    (false, false) => 0.7_f64.min(velocity.y + 0.06),
+                };
+                reset_fall |= !nothing_above;
+            }
+        }
+    }
+    reset_fall
+}
 /// Which fluids `FluidTags.WATER` and `FluidTags.LAVA` hold.
 pub struct FluidTags;
 impl FluidMembership for FluidTags {
diff --git a/crates/horizon-client/src/net.rs b/crates/horizon-client/src/net.rs
index 34daaf85c..93364ed91 100644
--- a/crates/horizon-client/src/net.rs
+++ b/crates/horizon-client/src/net.rs
@@ -68,6 +68,9 @@ pub enum Event {
         host: String,
         port: i32,
     },
+    /// `ClientboundServerLinksPacket`: the links the pause menu's "Server
+    /// Links..." lists (ClientCommonPacketListenerImpl.handleServerLinks).
+    ServerLinks(Vec<cfg::ServerLink>),
     /// The connection ended. `from_server`: the server gave the reason (or
     /// the connection was refused for good), rather than the connection
     /// failing (auto-reconnect retries only failures and shutdowns).
@@ -565,6 +568,9 @@ fn receive_play(
             play::Clientbound::StoreCookie(p) => {
                 cookies.lock().unwrap().insert(p.key, p.payload);
             }
+            play::Clientbound::ServerLinks(p) => {
+                let _ = send.send(Event::ServerLinks(p.links));
+            }
             // ClientCommonPacketListenerImpl.handleTransfer: the connection
             // ends and the game connects to the other address.
             play::Clientbound::Transfer(p) => {
@@ -644,6 +650,9 @@ fn configure(
             cfg::Clientbound::StoreCookie(p) => {
                 cookies.lock().unwrap().insert(p.key, p.payload);
             }
+            cfg::Clientbound::ServerLinks(p) => {
+                let _ = send.send(Event::ServerLinks(p.links));
+            }
             cfg::Clientbound::Transfer(p) => {
                 let _ = send.send(Event::Transfer {
                     host: p.host,
diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs
index 61fda9878..2b852a4af 100644
--- a/crates/horizon-client/src/options_ui.rs
+++ b/crates/horizon-client/src/options_ui.rs
@@ -4,6 +4,8 @@
 //! OptionsList screens and drawn with the shared widgets.
 use std::time::Instant;
 
+pub use crate::settings::Opt;
+
 use crate::{
     gamepad::{self, GlyphStyle},
     hud::{HudAtlas, HudBatch, rgba},
@@ -14,93 +16,6 @@ use crate::{
     ui,
 };
 
-/// One option instance.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Opt {
-    Fov,
-    RenderDistance,
-    SimulationDistance,
-    Sensitivity,
-    WheelSensitivity,
-    InvertY,
-    DiscreteScroll,
-    Volume(usize),
-    GuiScale,
-    ViewBobbing,
-    Gamma,
-    MaxFps,
-    Vsync,
-    Fullscreen,
-    SmoothLighting,
-    Clouds,
-    CloudRange,
-    Particles,
-    EntityDistance,
-    EntityShadows,
-    BiomeBlend,
-    Preset,
-    Mipmaps,
-    WeatherRadius,
-    ChunkFade,
-    Vignette,
-    Autosave,
-    CutoutLeaves,
-    ImprovedTransparency,
-    AttackIndicator,
-    InactivityFps,
-    ChunkBuilder,
-    MenuBlur,
-    ToggleCrouch,
-    ToggleSprint,
-    AutoJump,
-    ChatVisibility,
-    ChatColors,
-    ChatLinks,
-    ChatOpacity,
-    TextBackgroundOpacity,
-    ChatScale,
-    ChatWidth,
-    ChatHeightFocused,
-    ChatHeightUnfocused,
-    ChatLineSpacing,
-    AutoSuggestions,
-    ReducedDebugInfo,
-    HighContrast,
-    ShowSubtitles,
-    NotificationDisplayTime,
-    Narrator,
-    TextBackground,
-    ChatDelay,
-    DistortionEffects,
-    FovEffects,
-    DarknessPulsing,
-    DamageTilt,
-    GlintSpeed,
-    GlintStrength,
-    HideLightningFlashes,
-    MonochromeLogo,
-    PanoramaSpeed,
-    HideSplashTexts,
-    NarratorHotkey,
-    RotateWithMinecarts,
-    HighContrastBlockOutlines,
-    ForceUnicode,
-    JapaneseGlyphs,
-    /// Horizon's controller settings (`horizon-controller.txt`).
-    PadEnabled,
-    PadVibration,
-    PadAdaptiveTriggers,
-    PadLightbar,
-    PadLookSensitivity,
-    PadInvertX,
-    PadInvertY,
-    PadToggleSneak,
-    PadMoveDeadzone,
-    PadLookDeadzone,
-    PadGlyphs,
-    PadMenuNav,
-    PadKeyboard,
-}
 fn tr(key: &str) -> Text {
     Text::translate(key, &[])
 }
@@ -167,11 +82,13 @@ impl Opt {
                 | Opt::NarratorHotkey
                 | Opt::ChatDelay
                 | Opt::DistortionEffects
-                | Opt::GlintSpeed
-                | Opt::GlintStrength
                 | Opt::MonochromeLogo
                 | Opt::RotateWithMinecarts
                 | Opt::HighContrastBlockOutlines
+                // Saved, but nothing in rendering reads them yet.
+                | Opt::ChunkFade
+                | Opt::ImprovedTransparency
+                | Opt::ChunkBuilder
         )
     }
     fn file_key(self) -> Option<&'static str> {
@@ -192,6 +109,7 @@ impl Opt {
             Opt::NarratorHotkey => "narratorHotkey",
             Opt::RotateWithMinecarts => "rotateWithMinecart",
             Opt::HighContrastBlockOutlines => "highContrastBlockOutline",
+            Opt::MusicFrequency => "musicFrequency",
             _ => return None,
         })
     }
@@ -237,6 +155,7 @@ impl Opt {
             Opt::ChatVisibility => "options.chat.visibility",
             Opt::ChatColors => "options.chat.color",
             Opt::ChatLinks => "options.chat.links",
+            Opt::ChatLinksPrompt => "options.chat.links.prompt",
             Opt::ChatOpacity => "options.chat.opacity",
             Opt::TextBackgroundOpacity => "options.accessibility.text_background_opacity",
             Opt::ChatScale => "options.chat.scale",
@@ -248,6 +167,7 @@ impl Opt {
             Opt::ReducedDebugInfo => "options.reducedDebugInfo",
             Opt::HighContrast => "options.accessibility.high_contrast",
             Opt::ShowSubtitles => "options.showSubtitles",
+            Opt::MusicFrequency => "options.music_frequency",
             Opt::NotificationDisplayTime => "options.notifications.display_time",
             Opt::Narrator => "options.narrator",
             Opt::TextBackground => "options.accessibility.text_background",
@@ -574,10 +494,16 @@ impl Opt {
             ][usize::from(s.chat_visibility.min(2))]),
             Opt::ChatColors => on_off(s.chat_colors),
             Opt::ChatLinks => on_off(s.chat_links),
+            Opt::ChatLinksPrompt => on_off(s.chat_links_prompt),
             Opt::AutoSuggestions => on_off(s.auto_suggestions),
             Opt::ReducedDebugInfo => on_off(s.reduced_debug_info),
             Opt::HighContrast => on_off(s.high_contrast),
             Opt::ShowSubtitles => on_off(s.show_subtitles),
+            Opt::MusicFrequency => tr([
+                "options.music_frequency.default",
+                "options.music_frequency.frequent",
+                "options.music_frequency.constant",
+            ][s.file.int("musicFrequency").clamp(0, 2) as usize]),
             Opt::ForceUnicode => on_off(s.force_unicode),
             Opt::JapaneseGlyphs => on_off(s.japanese_glyphs),
             Opt::PadEnabled => on_off(s.controller.enabled),
@@ -625,10 +551,12 @@ impl Opt {
                 self.file_key().unwrap(),
                 crate::options_file::V::Double(f64::from(v).powi(2)),
             ),
-            Opt::DamageTilt | Opt::PanoramaSpeed => s.file.set(
-                self.file_key().unwrap(),
-                crate::options_file::V::Double(f64::from(v)),
-            ),
+            Opt::DamageTilt | Opt::PanoramaSpeed | Opt::GlintSpeed | Opt::GlintStrength => {
+                s.file.set(
+                    self.file_key().unwrap(),
+                    crate::options_file::V::Double(f64::from(v)),
+                )
+            }
             Opt::Fov => s.fov = step(30.0, 110.0),
             Opt::RenderDistance => s.render_distance = step(2.0, 64.0) as i32,
             Opt::SimulationDistance => s.simulation_distance = step(5.0, 32.0) as i32,
@@ -680,6 +608,7 @@ impl Opt {
                 | Opt::CutoutLeaves
                 | Opt::ImprovedTransparency
                 | Opt::MenuBlur
+                | Opt::ChunkBuilder
         )
     }
     /// Advance a cycle button (CycleButton.cycleValue).
@@ -743,10 +672,16 @@ impl Opt {
             Opt::ChatVisibility => s.chat_visibility = next(s.chat_visibility, 3),
             Opt::ChatColors => s.chat_colors = !s.chat_colors,
             Opt::ChatLinks => s.chat_links = !s.chat_links,
+            Opt::ChatLinksPrompt => s.chat_links_prompt = !s.chat_links_prompt,
             Opt::AutoSuggestions => s.auto_suggestions = !s.auto_suggestions,
             Opt::ReducedDebugInfo => s.reduced_debug_info = !s.reduced_debug_info,
             Opt::HighContrast => s.high_contrast = !s.high_contrast,
             Opt::ShowSubtitles => s.show_subtitles = !s.show_subtitles,
+            Opt::MusicFrequency => {
+                let n = next(s.file.int("musicFrequency").clamp(0, 2) as u8, 3);
+                s.file
+                    .set("musicFrequency", crate::options_file::V::Int(i32::from(n)));
+            }
             Opt::ForceUnicode => s.force_unicode = !s.force_unicode,
             Opt::JapaneseGlyphs => s.japanese_glyphs = !s.japanese_glyphs,
             Opt::PadEnabled => s.controller.enabled = !s.controller.enabled,
@@ -1412,6 +1347,9 @@ impl OptionsUi {
                 let others: Vec<Opt> = (1..SOUND_SOURCES.len()).map(Opt::Volume).collect();
                 rows.extend(pairs(&others));
                 rows.extend(pairs(&[Opt::ShowSubtitles]));
+                // SoundOptionsScreen: Music Frequency starts the next row (with
+                // Music Toast, not in Horizon yet).
+                rows.extend(pairs(&[Opt::MusicFrequency]));
                 rows
             }
             Page::Controls => {
@@ -1487,6 +1425,7 @@ impl OptionsUi {
                 Opt::ChatVisibility,
                 Opt::ChatColors,
                 Opt::ChatLinks,
+                Opt::ChatLinksPrompt,
                 Opt::ChatOpacity,
                 Opt::TextBackgroundOpacity,
                 Opt::ChatScale,
@@ -2533,6 +2472,21 @@ impl OptionsUi {
                             if opt == Opt::Preset {
                                 apply_preset(s);
                             }
+                            if opt == Opt::HighContrast {
+                                // Options.highContrast: the built-in pack follows the option.
+                                let on = s.resource_packs.iter().any(|id| id == "high_contrast");
+                                if on != s.high_contrast {
+                                    s.resource_packs.retain(|id| id != "high_contrast");
+                                    if s.high_contrast {
+                                        s.resource_packs.push("high_contrast".into());
+                                    }
+                                    // PackSelectionScreen reads the repository each time it
+                                    // opens: the next one starts from this selection.
+                                    self.pack_selection = s.resource_packs.clone();
+                                    self.pack_screen = None;
+                                    events.push(Event::Packs(s.resource_packs.clone()));
+                                }
+                            }
                             events.push(Event::Changed);
                         }
                         Act::Extra(item) => {
@@ -2701,6 +2655,7 @@ impl OptionsUi {
                 {
                     let ids = p.commit();
                     s.resource_packs = ids.clone();
+                    self.pack_selection = ids.clone();
                     events.push(Event::Packs(ids));
                 }
             }
diff --git a/crates/horizon-client/src/packs.rs b/crates/horizon-client/src/packs.rs
index 1e012fd90..28952ba2c 100644
--- a/crates/horizon-client/src/packs.rs
+++ b/crates/horizon-client/src/packs.rs
@@ -4,9 +4,9 @@
 //! and an overlay resource root that layers the enabled packs over the
 //! vanilla resources (later packs win), so every loader sees one tree.
 mod cache;
-pub mod pattern;
 use crate::text::Style;
 use crate::{text::Text, zip::Zip};
+pub use horizon_client_core::pattern;
 use pattern::Pattern;
 use std::{
     collections::{BTreeMap, BTreeSet},
diff --git a/crates/horizon-client/src/particles.rs b/crates/horizon-client/src/particles.rs
index fa9dc9c6e..9d1c572a2 100644
--- a/crates/horizon-client/src/particles.rs
+++ b/crates/horizon-client/src/particles.rs
@@ -23,212 +23,7 @@ use std::{
     path::Path,
 };
 
-macro_rules! particle_types {
-    ($($variant:ident = $name:literal),* $(,)?) => {
-        /// Vanilla particle types with a client implementation here.
-        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-        pub enum ParticleType { $($variant),* }
-        impl ParticleType {
-            pub const ALL: &'static [ParticleType] = &[$(ParticleType::$variant),*];
-            /// Registry path (`minecraft:<name>`), also the sprite-set file name.
-            pub fn name(self) -> &'static str {
-                match self { $(ParticleType::$variant => $name),* }
-            }
-            pub fn from_name(name: &str) -> Option<Self> {
-                let name = name.strip_prefix("minecraft:").unwrap_or(name);
-                match name { $($name => Some(ParticleType::$variant),)* _ => None }
-            }
-        }
-    };
-}
-particle_types! {
-    Block = "block",
-    BlockCrumble = "block_crumble",
-    Trail = "trail",
-    DustPillar = "dust_pillar",
-    FallingDust = "falling_dust",
-    Smoke = "smoke",
-    LargeSmoke = "large_smoke",
-    WhiteSmoke = "white_smoke",
-    Flame = "flame",
-    SoulFireFlame = "soul_fire_flame",
-    CopperFireFlame = "copper_fire_flame",
-    SmallFlame = "small_flame",
-    Lava = "lava",
-    DrippingWater = "dripping_water",
-    FallingWater = "falling_water",
-    DrippingLava = "dripping_lava",
-    FallingLava = "falling_lava",
-    LandingLava = "landing_lava",
-    DrippingHoney = "dripping_honey",
-    FallingHoney = "falling_honey",
-    LandingHoney = "landing_honey",
-    FallingNectar = "falling_nectar",
-    FallingSporeBlossom = "falling_spore_blossom",
-    SporeBlossomAir = "spore_blossom_air",
-    DrippingObsidianTear = "dripping_obsidian_tear",
-    FallingObsidianTear = "falling_obsidian_tear",
-    LandingObsidianTear = "landing_obsidian_tear",
-    DrippingDripstoneWater = "dripping_dripstone_water",
-    FallingDripstoneWater = "falling_dripstone_water",
-    DrippingDripstoneLava = "dripping_dripstone_lava",
-    FallingDripstoneLava = "falling_dripstone_lava",
-    Splash = "splash",
-    Rain = "rain",
-    Bubble = "bubble",
-    SulfurBubbles = "sulfur_bubbles",
-    BubblePop = "bubble_pop",
-    BubbleColumnUp = "bubble_column_up",
-    CurrentDown = "current_down",
-    Underwater = "underwater",
-    Portal = "portal",
-    ReversePortal = "reverse_portal",
-    Enchant = "enchant",
-    Nautilus = "nautilus",
-    VaultConnection = "vault_connection",
-    Crit = "crit",
-    EnchantedHit = "enchanted_hit",
-    DamageIndicator = "damage_indicator",
-    Heart = "heart",
-    AngryVillager = "angry_villager",
-    HappyVillager = "happy_villager",
-    Composter = "composter",
-    Mycelium = "mycelium",
-    Dolphin = "dolphin",
-    EggCrack = "egg_crack",
-    Poof = "poof",
-    Explosion = "explosion",
-    ExplosionEmitter = "explosion_emitter",
-    CampfireCosySmoke = "campfire_cosy_smoke",
-    CampfireSignalSmoke = "campfire_signal_smoke",
-    Note = "note",
-    Dust = "dust",
-    TotemOfUndying = "totem_of_undying",
-    Firework = "firework",
-    EndRod = "end_rod",
-    Ash = "ash",
-    WhiteAsh = "white_ash",
-    CrimsonSpore = "crimson_spore",
-    WarpedSpore = "warped_spore",
-    CherryLeaves = "cherry_leaves",
-    PaleOakLeaves = "pale_oak_leaves",
-    TintedLeaves = "tinted_leaves",
-    Effect = "effect",
-    InstantEffect = "instant_effect",
-    EntityEffect = "entity_effect",
-    Witch = "witch",
-    Infested = "infested",
-    Cloud = "cloud",
-    Sneeze = "sneeze",
-    Snowflake = "snowflake",
-    Soul = "soul",
-    SculkSoul = "sculk_soul",
-    DragonBreath = "dragon_breath",
-    Gust = "gust",
-    SmallGust = "small_gust",
-    GustEmitterLarge = "gust_emitter_large",
-    GustEmitterSmall = "gust_emitter_small",
-    DustColorTransition = "dust_color_transition",
-    SculkCharge = "sculk_charge",
-    SculkChargePop = "sculk_charge_pop",
-    Shriek = "shriek",
-    SonicBoom = "sonic_boom",
-    Vibration = "vibration",
-    SweepAttack = "sweep_attack",
-    Glow = "glow",
-    WaxOn = "wax_on",
-    WaxOff = "wax_off",
-    ElectricSpark = "electric_spark",
-    Scrape = "scrape",
-    SquidInk = "squid_ink",
-    GlowSquidInk = "glow_squid_ink",
-    Item = "item",
-    ItemSlime = "item_slime",
-    ItemSnowball = "item_snowball",
-    ItemCobweb = "item_cobweb",
-    SulfurCubeGoo = "sulfur_cube_goo",
-    Flash = "flash",
-    Firefly = "firefly",
-    TrialSpawnerDetection = "trial_spawner_detection",
-    TrialSpawnerDetectionOminous = "trial_spawner_detection_ominous",
-    TrialOmen = "trial_omen",
-    RaidOmen = "raid_omen",
-    OminousSpawning = "ominous_spawning",
-    Spit = "spit",
-    Fishing = "fishing",
-    DustPlume = "dust_plume",
-    RedPoplarLeaves = "red_poplar_leaves",
-    OrangePoplarLeaves = "orange_poplar_leaves",
-    YellowPoplarLeaves = "yellow_poplar_leaves",
-    PauseMobGrowth = "pause_mob_growth",
-    ResetMobGrowth = "reset_mob_growth",
-    BlockMarker = "block_marker",
-}
-impl ParticleType {
-    /// `ParticleType.getOverrideLimiter` (`ParticleTypes.register(name, true)`):
-    /// spawned regardless of distance.
-    pub fn override_limiter(self) -> bool {
-        matches!(
-            self,
-            Self::BlockMarker
-                | Self::DamageIndicator
-                | Self::ExplosionEmitter
-                | Self::Explosion
-                | Self::Gust
-                | Self::GustEmitterLarge
-                | Self::GustEmitterSmall
-                | Self::SonicBoom
-                | Self::SculkCharge
-                | Self::SculkChargePop
-                | Self::Vibration
-                | Self::Poof
-                | Self::Spit
-                | Self::SquidInk
-                | Self::SweepAttack
-                | Self::CampfireCosySmoke
-                | Self::CampfireSignalSmoke
-                | Self::GlowSquidInk
-                | Self::Glow
-                | Self::WaxOn
-                | Self::WaxOff
-                | Self::ElectricSpark
-                | Self::Scrape
-                | Self::TrialSpawnerDetection
-                | Self::TrialSpawnerDetectionOminous
-                | Self::VaultConnection
-                | Self::OminousSpawning
-        )
-    }
-    /// `SingleQuadParticle.Layer.translucent`: types whose vanilla particle class
-    /// hardcodes the translucent layer, drawn after translucent terrain.
-    /// `TerrainParticle`, `BreakingItemParticle` and `BlockMarker` resolve their
-    /// layer from the sprite instead (`Layer.bySprite`); see the `translucent`
-    /// sprite set on the engine.
-    pub fn translucent_layer(self) -> bool {
-        match self {
-            // CampfireSmokeParticle.
-            Self::CampfireCosySmoke | Self::CampfireSignalSmoke
-            // PlayerCloudParticle.
-            | Self::Cloud | Self::Sneeze
-            // SpellParticle.
-            | Self::Effect | Self::InstantEffect | Self::EntityEffect
-            | Self::Witch | Self::Infested | Self::TrialOmen | Self::RaidOmen
-            // EmissiveRisingParticle.
-            | Self::Soul | Self::SculkSoul
-            // SculkChargeParticle, SculkChargePopParticle, ShriekParticle,
-            // VibrationSignalParticle, FireflyParticle, OverlayParticle.
-            | Self::SculkCharge | Self::SculkChargePop | Self::Shriek
-            | Self::Vibration | Self::Firefly | Self::Flash
-            // SimpleAnimatedParticle and its subclasses: EndRodParticle,
-            // SparkParticle (firework), SquidInkParticle, TotemParticle.
-            | Self::EndRod | Self::Firework | Self::SquidInk | Self::GlowSquidInk
-            | Self::TotemOfUndying
-            // FlyTowardsPositionParticle: its LifetimeAlpha(0, 0.6, 0.25, 1) is not opaque.
-            | Self::VaultConnection => true,
-            _ => false,
-        }
-    }
-}
+pub use horizon_client_core::particle_type::ParticleType;
 
 /// `ParticleOptions` with the parameters of the option classes used here.
 #[derive(Clone, Debug)]
@@ -751,6 +546,17 @@ fn next_double_between(random: &mut impl RandomSource, min: f64, max: f64) -> f6
 pub fn on_block_faces(
     random: &mut impl RandomSource,
     pos: [i32; 3],
+    emit: impl FnMut([f64; 3], [f64; 3]),
+) {
+    on_block_faces_between(random, pos, 3, 5, emit);
+}
+/// `ParticleUtils.spawnParticlesOnBlockFaces` with `UniformInt.of(min, max)`
+/// particles per face (3009 sniffer egg cracks use 3 to 6).
+pub fn on_block_faces_between(
+    random: &mut impl RandomSource,
+    pos: [i32; 3],
+    min: i32,
+    max: i32,
     mut emit: impl FnMut([f64; 3], [f64; 3]),
 ) {
     const FACES: [[i32; 3]; 6] = [
@@ -762,7 +568,7 @@ pub fn on_block_faces(
         [1, 0, 0],
     ];
     for face in FACES {
-        let count = random.next_int_bound(5 - 3 + 1).unwrap_or(0) + 3;
+        let count = random.next_int_bound(max - min + 1).unwrap_or(0) + min;
         for _ in 0..count {
             // getRandomSpeedRanges, then spawnParticleOnFace with step factor 0.55.
             let speed: [f64; 3] = std::array::from_fn(|_| next_double_between(random, -0.5, 0.5));
@@ -1188,6 +994,8 @@ pub struct ParticleEngine {
     emitters: Vec<(ParticleOptions, [f64; 3], f64, f64, u32)>,
     /// Camera position for the 32-block spawn limiter.
     pub camera: [f64; 3],
+    /// The Particles option (`ParticleStatus`): 0 all, 1 decreased, 2 minimal.
+    pub particle_level: u8,
     /// FireworkParticles.Starter instances.
     starters: Vec<Starter>,
     /// Local sounds requested by particles (dripstone drips): (event, position, volume, pitch).
@@ -1218,6 +1026,7 @@ impl ParticleEngine {
             emitters: Vec::new(),
             starters: Vec::new(),
             camera: [0.0; 3],
+            particle_level: 0,
             sounds: Vec::new(),
             made: Default::default(),
             item_sprites: HashMap::new(),
@@ -1328,30 +1137,48 @@ impl ParticleEngine {
         &mut self.level_random
     }
     /// `ClientLevel.addParticle`: dropped beyond 32 blocks of the camera unless
-    /// the type overrides the limiter.
+    /// the type overrides the limiter, and thinned by the Particles option.
     pub fn add(&mut self, options: &ParticleOptions, p: [f64; 3], v: [f64; 3]) {
+        self.add_with(options, p, v, false, false);
+    }
+    /// `ClientLevel.addParticle(particle, overrideLimiter, alwaysShow, ...)`
+    /// (`doAddParticle`). `always_show` is `addAlwaysVisibleParticle`'s flag.
+    pub fn add_with(
+        &mut self,
+        options: &ParticleOptions,
+        p: [f64; 3],
+        v: [f64; 3],
+        override_limiter: bool,
+        always_show: bool,
+    ) {
         let c = self.camera;
         let d2 = (p[0] - c[0]).powi(2) + (p[1] - c[1]).powi(2) + (p[2] - c[2]).powi(2);
         if let Some(requested) = &mut self.requested {
             requested.push((options.clone(), p, v));
             return;
         }
-        if !options.ty.override_limiter() && d2 > 1024.0 {
-            return;
+        let minimal = self.calculate_particle_level(always_show) == 2;
+        if override_limiter || options.ty.override_limiter() || (d2 <= 1024.0 && !minimal) {
+            self.create(options, p, v);
         }
-        self.create(options, p, v);
+    }
+    /// `ClientLevel.calculateParticleLevel`: minimal still shows one in ten
+    /// always-visible particles as decreased, and decreased drops a third.
+    fn calculate_particle_level(&mut self, always_show: bool) -> u8 {
+        let mut level = self.particle_level.min(2);
+        if always_show && level == 2 && self.level_random.next_int_bound(10).unwrap_or(0) == 0 {
+            level = 1;
+        }
+        if level == 1 && self.level_random.next_int_bound(3).unwrap_or(0) == 0 {
+            level = 2;
+        }
+        level
     }
     /// `LevelEventHandler.singleBlockTeleportationParticles` towards
     /// `BlockUtil.unpackDifferenceInPosition(from, data, radius)`: the dragon
     /// egg's event 2015 packs offsets within (16, 8, 16), a consumable's
     /// teleport (2017) within (127, 127, 127).
-    pub fn block_teleportation(
-        &mut self,
-        from: [i32; 3],
-        data: i32,
-        radius: [i32; 3],
-        particle_level: u8,
-    ) {
+    pub fn block_teleportation(&mut self, from: [i32; 3], data: i32, radius: [i32; 3]) {
         let to = [
             from[0].wrapping_add(((data >> 16) & 255) - radius[0]),
             from[1].wrapping_add(((data >> 8) & 255) - radius[1]),
@@ -1369,28 +1196,21 @@ impl ParticleEngine {
                 to[1] + t * (from[1] - to[1]) + r.next_double() - 0.5,
                 to[2] + t * (from[2] - to[2]) + (r.next_double() - 0.5) + 0.5,
             ];
-            // The option roll shares the level random and precedes the distance check.
-            let limited = match particle_level {
-                1 => r.next_int_bound(3).unwrap_or(0) == 0,
-                2 => true,
-                _ => false,
-            };
-            if !limited {
-                self.add(&options, position, velocity);
-            }
+            self.add(&options, position, velocity);
         }
     }
     /// `ClientPacketListener.handleExplosion` + `ClientExplosionTracker`: the
-    /// explosion particle (emitter for radius >= 2) and up to 512 poof/smoke
-    /// particles thrown from air inside the radius.
+    /// explosion particle (the emitter unless `ServerExplosion.isSmall`) and up
+    /// to 512 poof/smoke particles thrown from air inside the radius.
     pub fn explosion(
         &mut self,
         center: [f64; 3],
-        radius: f32,
+        small: bool,
         block_count: usize,
+        radius: f32,
         is_air: &dyn Fn([i32; 3]) -> bool,
     ) {
-        let ty = if radius < 2.0 {
+        let ty = if small {
             ParticleType::Explosion
         } else {
             ParticleType::ExplosionEmitter
@@ -1398,6 +1218,18 @@ impl ParticleEngine {
         self.add(&ParticleOptions::simple(ty), center, [1.0, 0.0, 0.0]);
         self.explosion_blocks(center, radius, block_count, is_air);
     }
+    /// `LlamaSpit.recreateFromPacket`: seven spit particles thrown ahead of a
+    /// new spit, each faster than the last along x and z.
+    pub fn llama_spit_burst(&mut self, at: [f64; 3], movement: [f64; 3]) {
+        for i in 0..7 {
+            let k = 0.4 + 0.1 * f64::from(i);
+            self.add(
+                &ParticleOptions::simple(ParticleType::Spit),
+                at,
+                [movement[0] * k, movement[1], movement[2] * k],
+            );
+        }
+    }
     /// `ClientExplosionTracker` with `Level.DEFAULT_EXPLOSION_BLOCK_PARTICLES`.
     pub fn explosion_blocks(
         &mut self,
@@ -1406,6 +1238,10 @@ impl ParticleEngine {
         block_count: usize,
         is_air: &dyn Fn([i32; 3]) -> bool,
     ) {
+        // ClientExplosionTracker.tick: only the All option throws the debris.
+        if self.particle_level != 0 {
+            return;
+        }
         for _ in 0..block_count.min(512) {
             let r = &mut self.random;
             let d = Vec3::new(
@@ -3946,6 +3782,8 @@ impl ParticleEngine {
                         },
                         color,
                         light,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
@@ -3970,7 +3808,7 @@ mod tests {
         let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
         engine.seed_randoms(0, 0, 0);
         // Destination offset (-15, 7, 15); the unused top byte is ignored.
-        engine.block_teleportation([4, 12, -5], 0xff01_0f1fu32 as i32, [16, 8, 16], 0);
+        engine.block_teleportation([4, 12, -5], 0xff01_0f1fu32 as i32, [16, 8, 16]);
         assert_eq!(engine.pending.len(), 128);
         assert!(engine.pending.iter().all(|p| p.ty == ParticleType::Portal));
         let first = &engine.pending[0];
@@ -3997,7 +3835,7 @@ mod tests {
         // TeleportRandomlyConsumeEffect: BlockUtil.clampedPackDifferenceInPosition
         // of the move (-7, -3, 9) with radii 127, from (4, 12, -5) to (-3, 9, 4).
         let data = (-7 + 127) << 16 | (-3 + 127) << 8 | (9 + 127);
-        engine.block_teleportation([4, 12, -5], data, [127, 127, 127], 0);
+        engine.block_teleportation([4, 12, -5], data, [127, 127, 127]);
         assert_eq!(engine.pending.len(), 128);
         for p in &engine.pending {
             let [x, y, z] = p.position;
@@ -4023,7 +3861,8 @@ mod tests {
                 if distant {
                     engine.camera = [1000.0; 3];
                 }
-                engine.block_teleportation([4, 12, -5], 0x010f1f, [16, 8, 16], option);
+                engine.particle_level = option;
+                engine.block_teleportation([4, 12, -5], 0x010f1f, [16, 8, 16]);
                 assert_eq!(engine.pending.len(), if distant { 0 } else { count });
                 assert_eq!(engine.level_random.state(), state);
             }
diff --git a/crates/horizon-client/src/poi_sections.rs b/crates/horizon-client/src/poi_sections.rs
index 79ff0441d..a806706a1 100644
--- a/crates/horizon-client/src/poi_sections.rs
+++ b/crates/horizon-client/src/poi_sections.rs
@@ -79,6 +79,15 @@ impl<T: Copy> PoiSections<T> {
     }
 }
 
+/// The POI types villagers use.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Poi {
+    /// A job site, by profession index.
+    Job(u8),
+    Home,
+    Meeting,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/horizon-client/src/pose.rs b/crates/horizon-client/src/pose.rs
index e34b1f1fc..2a01579f3 100644
--- a/crates/horizon-client/src/pose.rs
+++ b/crates/horizon-client/src/pose.rs
@@ -15,8 +15,21 @@ pub enum Pose {
     Swimming,
     FallFlying,
     SpinAttack,
+    Sleeping,
 }
 impl Pose {
+    /// `Pose` by its network id (`Pose.id`); the poses a player never takes
+    /// are standing.
+    pub fn from_id(id: i32) -> Self {
+        match id {
+            1 => Self::FallFlying,
+            2 => Self::Sleeping,
+            3 => Self::Swimming,
+            4 => Self::SpinAttack,
+            5 => Self::Crouching,
+            _ => Self::Standing,
+        }
+    }
     pub fn name(self) -> &'static str {
         match self {
             Self::Standing => "STANDING",
@@ -24,18 +37,24 @@ impl Pose {
             Self::Swimming => "SWIMMING",
             Self::FallFlying => "FALL_FLYING",
             Self::SpinAttack => "SPIN_ATTACK",
+            Self::Sleeping => "SLEEPING",
         }
     }
+    /// `Avatar.POSES` (and `LivingEntity.SLEEPING_DIMENSIONS`): the box of a
+    /// player or mannequin in this pose; sleeping ignores the scale.
     pub fn dimensions(self, scale: f32) -> Dimensions {
-        let (height, eye_height) = match self {
-            Self::Standing => (1.8, 1.62),
-            Self::Crouching => (1.5, 1.27),
-            Self::Swimming | Self::FallFlying | Self::SpinAttack => (0.6, 0.4),
+        let (width, height, eye_height) = match self {
+            Self::Standing => (0.6 * scale, 1.8 * scale, 1.62 * scale),
+            Self::Crouching => (0.6 * scale, 1.5 * scale, 1.27 * scale),
+            Self::Swimming | Self::FallFlying | Self::SpinAttack => {
+                (0.6 * scale, 0.6 * scale, 0.4 * scale)
+            }
+            Self::Sleeping => (0.2, 0.2, 0.2),
         };
         Dimensions {
-            width: 0.6 * scale,
-            height: height * scale,
-            eye_height: eye_height * scale,
+            width,
+            height,
+            eye_height,
         }
     }
 }
@@ -73,6 +92,19 @@ impl PlayerMotion {
         }
         Ok(())
     }
+    /// `LivingEntity.startSleeping` and `stopSleeping` set the pose at once
+    /// (the 0.2 box in the bed, standing again after).
+    pub fn set_sleeping(&mut self, sleeping: bool) -> Result<()> {
+        if self.sleeping != sleeping {
+            self.sleeping = sleeping;
+            self.set_pose(if sleeping {
+                Pose::Sleeping
+            } else {
+                Pose::Standing
+            })?;
+        }
+        Ok(())
+    }
     pub fn moving_slowly(&self) -> bool {
         self.local_crouching || (self.pose == Pose::Swimming && !self.fluids.was_touching_water)
     }
@@ -100,8 +132,10 @@ impl MotionWorld<'_, '_, '_> {
         if !self.can_fit_pose(Pose::Swimming)? {
             return Ok(());
         }
-        // Player.getDesiredPose: swimming, gliding, Riptide's spin.
-        let desired = if self.player.swimming {
+        // Player.getDesiredPose: sleeping, swimming, gliding, Riptide's spin.
+        let desired = if self.player.sleeping {
+            Pose::Sleeping
+        } else if self.player.swimming {
             Pose::Swimming
         } else if self.player.fall_flying {
             Pose::FallFlying
diff --git a/crates/horizon-client/src/projectiles.rs b/crates/horizon-client/src/projectiles.rs
index 219d59b6b..b3e9938c9 100644
--- a/crates/horizon-client/src/projectiles.rs
+++ b/crates/horizon-client/src/projectiles.rs
@@ -28,6 +28,10 @@ pub enum ProjectileKind {
         critical: bool,
         effect: Option<(&'static str, i32)>,
     },
+    /// `ThrownTrident` of a mob (a drowned's): flies and sticks with
+    /// `AbstractArrow`'s tick; the trident itself is the arrow state's
+    /// `pickup_item`.
+    Trident,
     Snowball,
     Egg,
     EnderPearl,
@@ -66,6 +70,7 @@ impl ProjectileKind {
     pub fn id(&self) -> &'static str {
         match self {
             Self::Arrow { .. } => "minecraft:arrow",
+            Self::Trident => "minecraft:trident",
             Self::Snowball => "minecraft:snowball",
             Self::Egg => "minecraft:egg",
             Self::EnderPearl => "minecraft:ender_pearl",
@@ -104,6 +109,9 @@ pub struct Projectile {
     pub arrow: Option<Box<crate::arrows::ArrowState>>,
     /// `AbstractHurtingProjectile.accelerationPower`.
     pub acceleration: f64,
+    /// `Entity.needsSync`: a server tells its clients about the change this
+    /// tick instead of at the next update interval.
+    pub needs_sync: bool,
 }
 /// What a projectile struck this tick.
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -152,7 +160,7 @@ fn axis_of(d: u8) -> u8 {
 }
 impl Projectile {
     pub fn new(kind: ProjectileKind, position: Vec3, owner: Option<Who>) -> Self {
-        let kind_is_arrow = matches!(kind, ProjectileKind::Arrow { .. });
+        let kind_is_arrow = matches!(kind, ProjectileKind::Arrow { .. } | ProjectileKind::Trident);
         Self {
             id: 0,
             kind,
@@ -168,6 +176,7 @@ impl Projectile {
             left_owner: false,
             bonus: Default::default(),
             acceleration: 0.1,
+            needs_sync: false,
             arrow: kind_is_arrow.then(|| {
                 // Entity.random: seeded unpredictably, the position stands in.
                 Box::new(crate::arrows::ArrowState::new(
@@ -186,12 +195,13 @@ impl Projectile {
         self
     }
     /// The shooter's bow enchantments; Flame spawns the arrow burning for 100
-    /// seconds (`projectile_spawned` ignite).
+    /// seconds (`projectile_spawned` ignite), Piercing sets its pierce level.
     pub fn set_bonus(&mut self, bonus: crate::mobs::gear::ArrowBonus) {
-        if bonus.flame
-            && let Some(a) = self.arrow.as_mut()
-        {
-            a.ignite_for_seconds(100.0);
+        if let Some(a) = self.arrow.as_mut() {
+            if bonus.flame {
+                a.ignite_for_seconds(100.0);
+            }
+            a.pierce = bonus.pierce.min(127) as u8;
         }
         self.bonus = bonus;
     }
@@ -252,7 +262,7 @@ impl Projectile {
     }
     fn gravity(&self) -> f64 {
         match self.kind {
-            ProjectileKind::Arrow { .. } => 0.05,
+            ProjectileKind::Arrow { .. } | ProjectileKind::Trident => 0.05,
             ProjectileKind::SmallFireball
             | ProjectileKind::LargeFireball { .. }
             | ProjectileKind::WitherSkull { .. } => 0.0,
@@ -603,8 +613,8 @@ impl Projectile {
             | ProjectileKind::WitherSkull { .. } => {
                 self.apply_hurting_inertia(water);
             }
-            // Arrows tick with `arrows::tick`.
-            ProjectileKind::Arrow { .. } => {}
+            // Arrows and tridents tick with `arrows::tick`.
+            ProjectileKind::Arrow { .. } | ProjectileKind::Trident => {}
             ProjectileKind::WindCharge | ProjectileKind::BreezeWindCharge => {}
             // LlamaSpit.tick: gone in water; drag and gravity follow the move.
             ProjectileKind::LlamaSpit => {
@@ -745,7 +755,8 @@ impl Projectile {
             ProjectileKind::WindCharge | ProjectileKind::BreezeWindCharge => return None,
             ProjectileKind::WitherSkull { dangerous: false } => "entity/wither/wither",
             ProjectileKind::WitherSkull { dangerous: true } => "entity/wither/wither_invulnerable",
-            ProjectileKind::Arrow { .. } => return None,
+            // Drawn as their models by the game.
+            ProjectileKind::Arrow { .. } | ProjectileKind::Trident => return None,
         })
     }
     /// Render scale of the item billboard (fireball renderers).
diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs
index 5926e0a1d..e746bf946 100644
--- a/crates/horizon-client/src/save.rs
+++ b/crates/horizon-client/src/save.rs
@@ -339,59 +339,7 @@ impl SaveTables {
     }
 }
 
-/// A container's loot table and what Horizon rolled from it. Vanilla keeps
-/// `LootTable` and `LootTableSeed` until the container is first opened;
-/// Horizon rolls when it generates or loads the chunk, and saves the table
-/// again while the container still holds exactly the rolled items.
-#[derive(Clone, Debug, PartialEq)]
-pub struct RolledLoot {
-    pub pos: (i32, i32, i32),
-    pub table: String,
-    /// The saved `LootTableSeed`, written back unless 0 (trySaveLootTable).
-    pub seed: Option<i64>,
-    /// The rolled `Items`.
-    pub items: Tag,
-}
-impl RolledLoot {
-    /// Puts the loot table back in place of `Items` while they are still the
-    /// roll; false once the container holds anything else.
-    pub fn restore(&self, map: &mut Compound) -> bool {
-        if map.get(&"Items".into()) != Some(&self.items) {
-            return false;
-        }
-        map.remove(&"Items".into());
-        map.insert("LootTable".into(), string(&self.table));
-        if let Some(seed) = self.seed.filter(|s| *s != 0) {
-            map.insert("LootTableSeed".into(), Tag::Long(seed));
-        }
-        true
-    }
-}
-
-/// Save data loaded with a chunk that Horizon keeps but does not simulate.
-#[derive(Clone, Debug, Default)]
-pub struct ChunkExtras {
-    /// Chunk root keys written back as loaded (structures, PostProcessing,
-    /// InhabitedTime, blending data, ...).
-    pub root: Compound,
-    /// Block entities Horizon does not model.
-    pub block_entities: Vec<Tag>,
-    /// The NBT of the modelled block entities as loaded, to restore the fields and
-    /// detail Horizon does not model when it saves them (`block_entity_nbt::overlay`).
-    pub block_entity_sources: Vec<((i32, i32, i32), Tag)>,
-    /// Every saved block entity's position in the order of the save's list,
-    /// the order `SerializableChunkData` puts them in the chunk's maps.
-    pub block_entity_order: Vec<(i32, i32, i32)>,
-    /// Scheduled ticks (`block_ticks`/`fluid_ticks`): delays relative to the
-    /// save time. Registered with the level's tick scheduler on arrival and
-    /// replaced with the scheduler's pending ticks when saving.
-    pub block_ticks: Vec<SavedTick>,
-    pub fluid_ticks: Vec<SavedTick>,
-    /// Game time written as `LastUpdate`.
-    pub last_update: i64,
-    /// Containers still holding their loot table's roll.
-    pub rolled_loot: Vec<RolledLoot>,
-}
+pub use crate::chunk::{ChunkExtras, RolledLoot, SavedProto};
 
 fn tick_list(ticks: &[SavedTick], name: impl Fn(u32) -> Option<String>) -> Tag {
     Tag::List(
@@ -643,11 +591,22 @@ pub fn encode_block_entity(
                 entries.push(("custom_name", name.clone()));
             }
         }
+        // TheEndGatewayBlockEntity.saveAdditional.
+        BlockEntity::EndGateway(g) => {
+            entries.push(("Age", Tag::Long(g.age)));
+            if let Some(exit) = g.exit_portal {
+                entries.push(("exit_portal", Tag::IntArray(exit.to_vec())));
+            }
+            if g.exact_teleport {
+                entries.push(("ExactTeleport", Tag::Byte(1)));
+            }
+        }
         BlockEntity::Spawner(s) => entries.extend(s.save()),
         BlockEntity::TrialSpawner(s) => entries.extend(s.save()),
         BlockEntity::Vault(v) => entries.extend(v.save()),
         BlockEntity::Beehive(h) => entries.extend(h.to_nbt()),
         BlockEntity::CommandBlock(c) => entries.extend(c.save()),
+        BlockEntity::DaylightDetector => {}
     }
     Tag::compound(entries)
 }
@@ -701,11 +660,24 @@ fn roll_loaded_loot(
         biome,
     ))
 }
+/// `TheEndGatewayBlockEntity.loadAdditional`.
+pub fn decode_end_gateway(tag: &Tag) -> crate::containers::EndGateway {
+    crate::containers::EndGateway {
+        age: number(tag.get("Age")).unwrap_or(0),
+        exit_portal: tag
+            .get("exit_portal")
+            .and_then(crate::block_entity_nbt::gateway_exit),
+        exact_teleport: number(tag.get("ExactTeleport")).unwrap_or(0) != 0,
+    }
+}
 pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::containers::BlockEntity)> {
     use crate::containers::BlockEntity;
     let int = |k: &str| number(tag.get(k)).map(|v| v as i32);
     let id = text(tag.get("id"))?;
     let pos = (int("x")?, int("y")?, int("z")?);
+    if id == "minecraft:end_gateway" {
+        return Some((pos, BlockEntity::EndGateway(decode_end_gateway(tag))));
+    }
     if id == "minecraft:jukebox" {
         let record = tag.get("RecordItem").and_then(item_from_nbt);
         let ticks = number(tag.get("ticks_since_song_started")).unwrap_or(0);
@@ -845,7 +817,9 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain
         | BlockEntity::Lectern(_)
         | BlockEntity::Banner(_)
         | BlockEntity::CreakingHeart(_)
-        | BlockEntity::Skull(_) => {}
+        | BlockEntity::EndGateway(_)
+        | BlockEntity::Skull(_)
+        | BlockEntity::DaylightDetector => {}
         BlockEntity::Spawner(s) => **s = crate::mobs::spawner::Spawner::load(tag),
         BlockEntity::TrialSpawner(s) => **s = crate::mobs::trial_spawner::TrialSpawner::load(tag),
         BlockEntity::Vault(v) => **v = crate::vault::Vault::load(tag),
@@ -1526,21 +1500,6 @@ fn decode_column(
     Some(chunk)
 }
 
-/// A proto chunk saved before it became final. Decoration writes into a
-/// chunk's neighbours, and decorated chunks wait for theirs, so the chunks
-/// past the finished ones hold writes that generating them again would lose
-/// (whole structure pieces, trees, ores). Vanilla saves its proto chunks too.
-pub struct SavedProto {
-    /// Blocks, scheduled ticks (in `saved`) and post-processing marks.
-    pub column: Chunk,
-    /// Decorated itself (`features`), not only written to by its neighbours
-    /// (`terrain`).
-    pub decorated: bool,
-    /// Block entity data in placement order, with `x`, `y` and `z`.
-    pub block_entities: Vec<Tag>,
-    /// Entities placed by structures, with absolute `Pos`.
-    pub entities: Vec<Tag>,
-}
 pub fn encode_proto(
     proto: &SavedProto,
     registry: &BlockRegistry,
@@ -2433,28 +2392,7 @@ fn write_saved_data(world: &Path, name: &str, data: Tag) -> Result<()> {
         Tag::compound([("data", data), ("DataVersion", Tag::Int(DATA_VERSION))]),
     )
 }
-pub fn uuid_text(u: [i32; 4]) -> String {
-    let hex: String = u.iter().map(|v| format!("{:08x}", *v as u32)).collect();
-    format!(
-        "{}-{}-{}-{}-{}",
-        &hex[0..8],
-        &hex[8..12],
-        &hex[12..16],
-        &hex[16..20],
-        &hex[20..32]
-    )
-}
-pub fn uuid_from_text(s: &str) -> Option<[i32; 4]> {
-    let hex: String = s.chars().filter(|c| *c != '-').collect();
-    if hex.len() != 32 {
-        return None;
-    }
-    let mut out = [0i32; 4];
-    for (i, v) in out.iter_mut().enumerate() {
-        *v = u32::from_str_radix(&hex[i * 8..i * 8 + 8], 16).ok()? as i32;
-    }
-    Some(out)
-}
+pub use horizon_client_core::uuid::{uuid_from_text, uuid_text};
 /// A random (version 4) UUID as vanilla's four-int form.
 pub fn random_uuid() -> [i32; 4] {
     let t = std::time::SystemTime::now()
@@ -2761,7 +2699,7 @@ pub struct Level {
     pub xp_seed: i32,
     /// ServerPlayer.seenCredits: the end poem has been shown.
     pub seen_credits: bool,
-    /// Player.active_effects: (id, duration, amplifier, ambient, show_icon).
+    /// Player.active_effects: (id, duration, amplifier, ambient, show_particles).
     pub active_effects: Vec<(String, i32, i32, bool, bool)>,
     /// Player.EnderItems: the ender chest inventory (27 slots).
     pub ender_items: Vec<Option<crate::items::ItemStack>>,
@@ -3041,7 +2979,7 @@ impl Level {
                         get("duration").unwrap_or(0) as i32,
                         get("amplifier").unwrap_or(0) as i32,
                         get("ambient").unwrap_or(0) != 0,
-                        get("show_icon").is_none_or(|v| v != 0),
+                        get("show_particles").is_none_or(|v| v != 0),
                     ))
                 })
                 .collect(),
@@ -3143,14 +3081,14 @@ impl Level {
                 Tag::List(
                     self.active_effects
                         .iter()
-                        .map(|(id, duration, amplifier, ambient, icon)| {
+                        .map(|(id, duration, amplifier, ambient, particles)| {
                             Tag::compound([
                                 ("id", string(id)),
                                 ("duration", Tag::Int(*duration)),
                                 ("amplifier", Tag::Byte(*amplifier as i8)),
                                 ("ambient", Tag::Byte(i8::from(*ambient))),
-                                ("show_particles", Tag::Byte(1)),
-                                ("show_icon", Tag::Byte(i8::from(*icon))),
+                                ("show_particles", Tag::Byte(i8::from(*particles))),
+                                ("show_icon", Tag::Byte(i8::from(*particles))),
                             ])
                         })
                         .collect(),
@@ -3839,6 +3777,9 @@ impl<G: ChunkGenerator> ChunkGenerator for Persistent<G> {
     fn is_decorated(&self, proto: &crate::streaming::Proto) -> bool {
         self.inner.is_decorated(proto)
     }
+    fn light_view(&self, proto: &crate::streaming::Proto) -> Option<Chunk> {
+        self.inner.light_view(proto)
+    }
     fn save_protos(&self, protos: &[&crate::streaming::Proto]) {
         self.save
             .tables
@@ -4658,6 +4599,79 @@ mod tests {
     }
     use super::*;
 
+    #[test]
+    fn end_gateway_block_entity_round_trips() {
+        use crate::containers::{BlockEntity, EndGateway};
+        let plain = BlockEntity::for_block("minecraft:end_gateway").expect("gateway");
+        assert!(matches!(&plain, BlockEntity::EndGateway(g) if *g == EndGateway::default()));
+        for exit in [None, Some([8, 100, 0])] {
+            for exact in [false, true] {
+                let gateway = EndGateway {
+                    age: 201,
+                    exit_portal: exit,
+                    exact_teleport: exact,
+                };
+                let tag = encode_block_entity(
+                    (702, 100, 0),
+                    &BlockEntity::EndGateway(gateway.clone()),
+                    "minecraft:end_gateway",
+                );
+                assert_eq!(
+                    text(tag.get("id")).as_deref(),
+                    Some("minecraft:end_gateway")
+                );
+                assert_eq!(tag.get("Age"), Some(&Tag::Long(201)));
+                assert_eq!(
+                    tag.get("exit_portal"),
+                    exit.map(|p| Tag::IntArray(p.to_vec())).as_ref()
+                );
+                assert_eq!(
+                    tag.get("ExactTeleport"),
+                    exact.then_some(Tag::Byte(1)).as_ref()
+                );
+                let (pos, back) = decode_block_entity(&tag).expect("gateway");
+                assert_eq!(pos, (702, 100, 0));
+                assert!(matches!(back, BlockEntity::EndGateway(g) if g == gateway));
+            }
+        }
+    }
+
+    #[test]
+    fn end_gateway_exit_requires_spawnable_bounds() {
+        for (exit, valid) in [
+            (vec![-30_000_000, -20_000_000, -30_000_000], true),
+            (vec![29_999_999, 19_999_999, 29_999_999], true),
+            (vec![30_000_000, 0, 0], false),
+            (vec![0, 0, 30_000_000], false),
+            (vec![-30_000_001, 0, 0], false),
+            (vec![0, 0, -30_000_001], false),
+            (vec![0, 20_000_000, 0], false),
+            (vec![0, -20_000_001, 0], false),
+            (vec![i32::MIN, 0, 0], false),
+            (vec![0, 100], false),
+        ] {
+            let tag = Tag::compound([
+                ("id", string("minecraft:end_gateway")),
+                ("x", Tag::Int(702)),
+                ("y", Tag::Int(100)),
+                ("z", Tag::Int(0)),
+                ("exit_portal", Tag::IntArray(exit)),
+            ]);
+            let (_, crate::containers::BlockEntity::EndGateway(g)) =
+                decode_block_entity(&tag).unwrap()
+            else {
+                panic!("gateway");
+            };
+            assert_eq!(g.exit_portal.is_some(), valid);
+            let canonical = crate::block_entity_nbt::canonical(&tag).expect("gateway NBT");
+            assert_eq!(canonical.get("exit_portal").is_some(), valid);
+        }
+        assert_eq!(
+            decode_end_gateway(&Tag::Compound(Compound::new())),
+            crate::containers::EndGateway::default()
+        );
+    }
+
     #[test]
     fn skull_block_entity_keeps_its_profile() {
         // A placed `player_head` as vanilla saves it: the owning player's
@@ -5123,6 +5137,30 @@ mod tests {
         };
         assert_eq!(back.recipes_used.get("minecraft:cooked_porkchop"), Some(&3));
     }
+    /// The world's save (Level.write) writes the rules as they are now, and a
+    /// world opened again reads them back (#74).
+    #[test]
+    fn level_save_keeps_changed_rules() {
+        use crate::gamerules::{GameRules, Value};
+        let dir =
+            std::env::temp_dir().join(format!("horizon-gamerules-level-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        let mut level = super::Level::default();
+        level.write(&dir).unwrap();
+        // Rules changed while playing, then saved and loaded again.
+        let mut rules = GameRules::load(&dir);
+        assert_eq!(rules, GameRules::default());
+        assert!(rules.set("advance_time", Value::Bool(false)));
+        assert!(rules.set("advance_weather", Value::Bool(false)));
+        assert!(rules.set("random_tick_speed", Value::Int(0)));
+        level.game_rules = rules.by_name();
+        level.write(&dir).unwrap();
+        assert_eq!(GameRules::load(&dir), rules);
+        let read = super::Level::read(&dir).unwrap();
+        assert_eq!(read.game_rules, rules.by_name());
+        assert_eq!(read.game_rule("advance_time"), 0);
+        let _ = std::fs::remove_dir_all(dir);
+    }
 
     /// A save written before the key was namespaced holds an id twice, once bare: vanilla
     /// refuses such a furnace, so a load merges them under the full id.
diff --git a/crates/horizon-client/src/settings.rs b/crates/horizon-client/src/settings.rs
index 74c428923..0c59c18f9 100644
--- a/crates/horizon-client/src/settings.rs
+++ b/crates/horizon-client/src/settings.rs
@@ -5,11 +5,7 @@ use crate::keybinds::KeyBinds;
 use crate::options_file::{OptionsFile, V};
 use std::{fs, path::Path};
 
-/// SoundSource names in vanilla order.
-pub const SOUND_SOURCES: [&str; 11] = [
-    "master", "music", "record", "weather", "block", "hostile", "neutral", "player", "ambient",
-    "voice", "ui",
-];
+pub use horizon_client_core::sound_source::SOUND_SOURCES;
 
 /// Per-source volumes for the mixer (soundCategory_* except master).
 static SOURCE_VOLUMES: std::sync::RwLock<[f32; 11]> = std::sync::RwLock::new([1.0; 11]);
@@ -149,6 +145,7 @@ pub struct Settings {
     pub chat_visibility: u8,
     pub chat_colors: bool,
     pub chat_links: bool,
+    pub chat_links_prompt: bool,
     pub chat_opacity: f32,
     pub text_background_opacity: f32,
     pub chat_scale: f32,
@@ -234,6 +231,7 @@ impl Default for Settings {
             chat_visibility: 0,
             chat_colors: true,
             chat_links: true,
+            chat_links_prompt: true,
             chat_opacity: 1.0,
             text_background_opacity: 0.5,
             chat_scale: 1.0,
@@ -427,6 +425,7 @@ impl Settings {
             chat_visibility: f.int("chatVisibility") as u8,
             chat_colors: f.bool("chatColors"),
             chat_links: f.bool("chatLinks"),
+            chat_links_prompt: f.bool("chatLinksPrompt"),
             chat_opacity: f.double("chatOpacity") as f32,
             text_background_opacity: f.double("textBackgroundOpacity") as f32,
             chat_scale: f.double("chatScale") as f32,
@@ -510,6 +509,7 @@ impl Settings {
         put_i(&mut f, "chatVisibility", i32::from(self.chat_visibility));
         put_b(&mut f, "chatColors", self.chat_colors);
         put_b(&mut f, "chatLinks", self.chat_links);
+        put_b(&mut f, "chatLinksPrompt", self.chat_links_prompt);
         put_f(&mut f, "chatOpacity", self.chat_opacity);
         put_f(
             &mut f,
@@ -608,6 +608,96 @@ impl Settings {
     }
 }
 
+/// One option instance.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Opt {
+    Fov,
+    RenderDistance,
+    SimulationDistance,
+    Sensitivity,
+    WheelSensitivity,
+    InvertY,
+    DiscreteScroll,
+    Volume(usize),
+    GuiScale,
+    ViewBobbing,
+    Gamma,
+    MaxFps,
+    Vsync,
+    Fullscreen,
+    SmoothLighting,
+    Clouds,
+    CloudRange,
+    Particles,
+    EntityDistance,
+    EntityShadows,
+    BiomeBlend,
+    Preset,
+    Mipmaps,
+    WeatherRadius,
+    ChunkFade,
+    Vignette,
+    Autosave,
+    CutoutLeaves,
+    ImprovedTransparency,
+    AttackIndicator,
+    InactivityFps,
+    ChunkBuilder,
+    MenuBlur,
+    ToggleCrouch,
+    ToggleSprint,
+    AutoJump,
+    ChatVisibility,
+    ChatColors,
+    ChatLinks,
+    ChatLinksPrompt,
+    ChatOpacity,
+    TextBackgroundOpacity,
+    ChatScale,
+    ChatWidth,
+    ChatHeightFocused,
+    ChatHeightUnfocused,
+    ChatLineSpacing,
+    AutoSuggestions,
+    ReducedDebugInfo,
+    HighContrast,
+    ShowSubtitles,
+    MusicFrequency,
+    NotificationDisplayTime,
+    Narrator,
+    TextBackground,
+    ChatDelay,
+    DistortionEffects,
+    FovEffects,
+    DarknessPulsing,
+    DamageTilt,
+    GlintSpeed,
+    GlintStrength,
+    HideLightningFlashes,
+    MonochromeLogo,
+    PanoramaSpeed,
+    HideSplashTexts,
+    NarratorHotkey,
+    RotateWithMinecarts,
+    HighContrastBlockOutlines,
+    ForceUnicode,
+    JapaneseGlyphs,
+    /// Horizon's controller settings (`horizon-controller.txt`).
+    PadEnabled,
+    PadVibration,
+    PadAdaptiveTriggers,
+    PadLightbar,
+    PadLookSensitivity,
+    PadInvertX,
+    PadInvertY,
+    PadToggleSneak,
+    PadMoveDeadzone,
+    PadLookDeadzone,
+    PadGlyphs,
+    PadMenuNav,
+    PadKeyboard,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/horizon-client/src/shadows.rs b/crates/horizon-client/src/shadows.rs
index dece7f726..613eb0bb1 100644
--- a/crates/horizon-client/src/shadows.rs
+++ b/crates/horizon-client/src/shadows.rs
@@ -119,6 +119,8 @@ pub fn shadow(
                         layer: crate::gfx::SHADOW_OVERLAY,
                         color,
                         light: 240 | 240 << 8,
+
+                        glint_uv: [0.0, 0.0],
                     });
                 }
             }
diff --git a/crates/horizon-client/src/signs.rs b/crates/horizon-client/src/signs.rs
index 07217ed79..799210797 100644
--- a/crates/horizon-client/src/signs.rs
+++ b/crates/horizon-client/src/signs.rs
@@ -147,10 +147,10 @@ fn component_text(tag: &Tag) -> String {
                 _ => s,
             }
         }
-        Tag::Compound(_) => match tag.get("text") {
-            Some(Tag::String(t)) => t.to_string_lossy(),
-            _ => String::new(),
-        },
+        // Component.getString: translations and key binds resolved.
+        Tag::Compound(_) => {
+            crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(tag)).plain()
+        }
         _ => String::new(),
     }
 }
diff --git a/crates/horizon-client/src/skins.rs b/crates/horizon-client/src/skins.rs
index ee6851e00..740208973 100644
--- a/crates/horizon-client/src/skins.rs
+++ b/crates/horizon-client/src/skins.rs
@@ -116,20 +116,9 @@ pub fn unpack(value: &str, signature: Signature, valid_uris: &[&str]) -> Texture
 /// heads and mannequins read their profile this way, and `SkinManager` lets
 /// those textures be unsigned (`getInsecureSkinInformation`).
 pub fn profile_skin_url(profile: &serde_json::Value) -> Option<String> {
-    let value = profile
-        .get("properties")?
-        .as_array()?
-        .iter()
-        .find_map(|p| {
-            if p.get("name")?.as_str()? == "textures" {
-                p.get("value")?.as_str()
-            } else {
-                None
-            }
-        })?;
-    unpack(value, Signature::Unsigned, &TEXTURE_URIS).skin
+    let (value, signature) = parse_profile(profile).textures?;
+    unpack(&value, signature, &TEXTURE_URIS).skin
 }
-
 /// `profile_skin_url` on a block entity's `profile` NBT (`SkullBlockEntity`):
 /// the same `properties` list, held as a compound. A name-only profile (a
 /// string tag) has no properties and no skin URL.
@@ -164,13 +153,329 @@ pub fn profile_uuid_nbt(profile: &horizon_world::nbt::Tag) -> Option<u128> {
     }
 }
 
-fn nbt_text(tag: Option<&horizon_world::nbt::Tag>) -> Option<String> {
+pub(crate) fn nbt_text(tag: Option<&horizon_world::nbt::Tag>) -> Option<String> {
     match tag {
         Some(horizon_world::nbt::Tag::String(s)) => Some(s.to_string_lossy()),
         _ => None,
     }
 }
 
+/// `Either<String, UUID>`: the key a `Dynamic` `ResolvableProfile` resolves
+/// by (`ResolvableProfile.nameOrId`).
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum NameOrId {
+    Name(String),
+    Id(u128),
+}
+
+/// `GameProfile` as `fetchProfile` returns it: the account's id, name and
+/// property map (its `textures` property is the skin).
+#[derive(Clone, Debug)]
+pub struct ResolvedProfile {
+    pub id: u128,
+    pub name: String,
+    /// `(name, value, signature)` properties.
+    pub properties: Vec<(String, String, Option<String>)>,
+}
+impl ResolvedProfile {
+    /// `SessionService.getPackedTextures`: the `textures` property.
+    pub fn textures(&self) -> Option<(String, Signature)> {
+        self.properties
+            .iter()
+            .find(|(n, _, _)| n == "textures")
+            .map(|(_, v, s)| {
+                (
+                    v.clone(),
+                    if s.is_some() {
+                        Signature::Signed
+                    } else {
+                        Signature::Unsigned
+                    },
+                )
+            })
+    }
+}
+
+/// Where a `Dynamic` profile's resolution stands (`resolveProfile`'s future).
+#[derive(Clone, Debug)]
+pub enum Resolve {
+    Pending,
+    /// The services' answer: `None` for no profile or no answer, which the
+    /// cache holds like any result (`Optional.empty`).
+    Done(Option<ResolvedProfile>),
+}
+
+/// `ProfileResolver.Cached`: resolves a `Dynamic` profile through the
+/// services — `profileCacheByName` asks `profiles`/`getByName` for the id,
+/// `profileCacheById` asks `session`/`getProfileById` for the profile —
+/// at most 256 entries kept 10 minutes after their last use, fetched on
+/// background threads.
+pub struct Resolver {
+    entries: std::collections::HashMap<NameOrId, Entry>,
+    done: std::sync::mpsc::Receiver<(NameOrId, Option<ResolvedProfile>)>,
+    send: std::sync::mpsc::Sender<(NameOrId, Option<ResolvedProfile>)>,
+    last_sweep: std::time::Instant,
+}
+struct Entry {
+    touched: std::time::Instant,
+    /// `None` while the fetch is in flight.
+    resolved: Option<Option<ResolvedProfile>>,
+}
+/// `ProfileResolver.Cached`'s cache bounds.
+const MAX_PROFILES: usize = 256;
+const PROFILE_TTL: std::time::Duration = std::time::Duration::from_secs(10 * 60);
+
+/// `StringUtil.isValidPlayerName` (the check `fetchByName` makes first).
+fn valid_player_name(name: &str) -> bool {
+    name.encode_utf16().count() <= 16 && name.encode_utf16().all(|c| c > 32 && c < 127)
+}
+
+/// `fetchByNameOrId`: `getByName` answers `{id, name}`; `getProfileById`
+/// (`fetchProfile(id, requireSecure)`) answers `{id, name, properties}` —
+/// asked `unsigned=false` so the `textures` property is signed.
+fn resolve_profile(key: &NameOrId, doc: &serde_json::Value) -> Option<ResolvedProfile> {
+    let id = match key {
+        NameOrId::Id(id) => *id,
+        NameOrId::Name(name) => {
+            let url = crate::auth::endpoint(doc, "profiles", "getByName")?
+                .replace("{name}", &name.to_lowercase());
+            let body = http_get(&url)?;
+            let v: serde_json::Value = serde_json::from_slice(&body).ok()?;
+            crate::auth::parse_uuid(v.get("id")?.as_str()?)?
+        }
+    };
+    let url = crate::auth::endpoint(doc, "session", "getProfileById")?
+        .replace("{profileId}", &format!("{id:032x}"));
+    let separator = if url.contains('?') { '&' } else { '?' };
+    let body = http_get(&format!("{url}{separator}unsigned=false"))?;
+    let v: serde_json::Value = serde_json::from_slice(&body).ok()?;
+    Some(ResolvedProfile {
+        id: crate::auth::parse_uuid(v.get("id")?.as_str()?)?,
+        name: v.get("name")?.as_str()?.to_owned(),
+        properties: v
+            .get("properties")?
+            .as_array()?
+            .iter()
+            .map(|p| {
+                Some((
+                    p.get("name")?.as_str()?.to_owned(),
+                    p.get("value")?.as_str()?.to_owned(),
+                    p.get("signature")
+                        .and_then(|s| s.as_str())
+                        .map(str::to_owned),
+                ))
+            })
+            .collect::<Option<Vec<_>>>()?,
+    })
+}
+
+impl Default for Resolver {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl Resolver {
+    pub fn new() -> Self {
+        let (send, done) = std::sync::mpsc::channel();
+        Self {
+            entries: Default::default(),
+            done,
+            send,
+            last_sweep: std::time::Instant::now(),
+        }
+    }
+    /// `CacheBuilder.expireAfterAccess` with `maximumSize`.
+    fn sweep(&mut self) {
+        if self.last_sweep.elapsed() < std::time::Duration::from_secs(30) {
+            return;
+        }
+        self.last_sweep = std::time::Instant::now();
+        self.entries
+            .retain(|_, e| e.touched.elapsed() < PROFILE_TTL);
+        while self.entries.len() > MAX_PROFILES
+            && let Some(oldest) = self
+                .entries
+                .iter()
+                .min_by_key(|(_, e)| e.touched)
+                .map(|(k, _)| k.clone())
+        {
+            self.entries.remove(&oldest);
+        }
+    }
+    /// How the resolution of `key` stands, starting it the first time.
+    pub fn state(&mut self, key: &NameOrId) -> Resolve {
+        while let Ok((key, resolved)) = self.done.try_recv() {
+            self.entries.insert(
+                key,
+                Entry {
+                    touched: std::time::Instant::now(),
+                    resolved: Some(resolved),
+                },
+            );
+        }
+        self.sweep();
+        if let Some(entry) = self.entries.get_mut(key) {
+            entry.touched = std::time::Instant::now();
+            return match &entry.resolved {
+                Some(resolved) => Resolve::Done(resolved.clone()),
+                None => Resolve::Pending,
+            };
+        }
+        // `fetchByName` refuses an invalid name without a fetch; like every
+        // other empty answer that is the cached result.
+        let resolved = matches!(key, NameOrId::Name(name) if !valid_player_name(name));
+        self.entries.insert(
+            key.clone(),
+            Entry {
+                touched: std::time::Instant::now(),
+                resolved: resolved.then_some(None),
+            },
+        );
+        if resolved {
+            return Resolve::Done(None);
+        }
+        let (key, send) = (key.clone(), self.send.clone());
+        std::thread::spawn(move || {
+            let resolved = crate::auth::discovery()
+                .ok()
+                .and_then(|doc| resolve_profile(&key, &doc));
+            let _ = send.send((key, resolved));
+        });
+        Resolve::Pending
+    }
+}
+
+/// `ResolvableProfile` (an item's `minecraft:profile` component, a skull's
+/// `profile` tag): the `textures` property it carries, the key a `Dynamic`
+/// profile resolves by, and `partialProfile.id` — the fallback skin's key.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct ProfileInfo {
+    /// `GameProfile.id` (`DefaultPlayerSkin.get`).
+    pub id: u128,
+    /// The `textures` property's value and signature state, when present.
+    pub textures: Option<(String, Signature)>,
+    /// `Dynamic` profiles resolve by name or id.
+    pub dynamic: Option<NameOrId>,
+}
+
+/// A profile's `id`: `UUIDUtil.CODEC` (an int array of four, or a UUID
+/// string).
+fn profile_id(v: &serde_json::Value) -> Option<u128> {
+    match v {
+        serde_json::Value::Array(a) => {
+            let ints: Option<Vec<i64>> = a.iter().map(|x| x.as_i64()).collect();
+            let i = ints?;
+            (i.len() == 4).then(|| {
+                ((i[0] as u32 as u128) << 96)
+                    | ((i[1] as u32 as u128) << 64)
+                    | ((i[2] as u32 as u128) << 32)
+                    | i[3] as u32 as u128
+            })
+        }
+        serde_json::Value::String(s) => crate::auth::parse_uuid(s),
+        _ => None,
+    }
+}
+
+/// `ResolvableProfile`'s read of a `profile` value: a bare name is
+/// `createUnresolved` (the `PLAYER_NAME` codec's alternative), a compound
+/// `name` + `id` + `properties` (`Partial.MAP_CODEC` or a `GameProfile`).
+pub fn parse_profile(v: &serde_json::Value) -> ProfileInfo {
+    if let serde_json::Value::String(name) = v {
+        return ProfileInfo {
+            id: horizon_protocol::crypto::offline_uuid(name),
+            textures: None,
+            dynamic: valid_player_name(name).then(|| NameOrId::Name(name.clone())),
+        };
+    }
+    let name = v.get("name").and_then(|n| n.as_str()).map(str::to_owned);
+    let id = v.get("id").and_then(profile_id);
+    let properties = v.get("properties").and_then(|p| p.as_array());
+    let textures = properties
+        .into_iter()
+        .flatten()
+        .find(|p| p.get("name").and_then(|n| n.as_str()) == Some("textures"))
+        .and_then(|p| {
+            Some((
+                p.get("value")?.as_str()?.to_owned(),
+                if p.get("signature").is_some() {
+                    Signature::Signed
+                } else {
+                    Signature::Unsigned
+                },
+            ))
+        });
+    // `ResolvableProfile.create`: a Partial is Dynamic with no properties
+    // and exactly one of a name or an id.
+    let dynamic =
+        (properties.is_none_or(|p| p.is_empty()) && name.is_some() != id.is_some()).then(|| {
+            name.as_deref().map_or_else(
+                || NameOrId::Id(id.unwrap()),
+                |n| NameOrId::Name(n.to_owned()),
+            )
+        });
+    ProfileInfo {
+        // `createPartialProfile`: the id, else the name's offline UUID, else nil.
+        id: id
+            .or_else(|| name.as_deref().map(horizon_protocol::crypto::offline_uuid))
+            .unwrap_or(0),
+        textures,
+        dynamic,
+    }
+}
+
+/// `ResolvableProfile.create`'s `Dynamic` key from a skull's `profile` tag:
+/// a bare name string is `createUnresolved`, and a compound without
+/// properties and with exactly one of a name or an id is `Dynamic`.
+pub fn dynamic_nbt(profile: &horizon_world::nbt::Tag) -> Option<NameOrId> {
+    if let horizon_world::nbt::Tag::String(s) = profile {
+        let name = s.to_string_lossy();
+        return valid_player_name(&name).then_some(NameOrId::Name(name));
+    }
+    if matches!(profile.get("properties"), Some(horizon_world::nbt::Tag::List(l)) if !l.is_empty())
+    {
+        return None;
+    }
+    match (nbt_text(profile.get("name")), profile_uuid_nbt(profile)) {
+        (Some(name), None) => Some(NameOrId::Name(name)),
+        (None, Some(id)) => Some(NameOrId::Id(id)),
+        _ => None,
+    }
+}
+
+/// `PlayerSkinRenderCache.getOrDefault` for a head: the resolved skin once
+/// its texture is in the atlas (`atlas`), else `partialProfile`'s default.
+pub fn head_skin(
+    profile: &serde_json::Value,
+    resolver: &mut Resolver,
+    downloads: &mut Downloader,
+    atlas: impl Fn(&str) -> bool,
+) -> String {
+    let p = parse_profile(profile);
+    let property = p.textures.or_else(|| {
+        let key = p.dynamic.as_ref()?;
+        match resolver.state(key) {
+            Resolve::Done(Some(profile)) => profile.textures(),
+            _ => None,
+        }
+    });
+    if let Some((value, signature)) = property
+        && let Some(url) = unpack(&value, signature, &TEXTURE_URIS).skin
+        && let Some(hash) = texture_hash(&url)
+    {
+        let location = skin_location(&hash);
+        match downloads.state(Kind::Skin, &url) {
+            Download::Ready if atlas(&location) => return location,
+            // Its slot was evicted: offer the image again.
+            Download::Ready => {
+                downloads.again(&location);
+            }
+            _ => {}
+        }
+    }
+    crate::tab_list::default_skin(p.id).to_owned()
+}
+
 /// `MinecraftProfileTexture.getHash`: the base name of the URL's path.
 pub fn texture_hash(url: &str) -> Option<String> {
     let rest = url.split_once("://")?.1;
@@ -313,7 +618,16 @@ pub struct Downloader {
     done: std::sync::mpsc::Receiver<((Kind, String), Option<Vec<u8>>)>,
     send: std::sync::mpsc::Sender<((Kind, String), Option<Vec<u8>>)>,
     ready: Vec<(String, Vec<u8>)>,
+    /// Locations already in `ready`, so `again` does not double-queue.
+    queued: std::collections::HashSet<String>,
+    /// Decoded skin images by location, kept so a skin evicted from the
+    /// atlas uploads again (`again`); the disk cache backs anything dropped.
+    images: std::collections::HashMap<String, Vec<u8>>,
+    image_order: std::collections::VecDeque<String>,
 }
+/// `images` is bounded only so a long session on a busy server does not grow
+/// without end; the disk cache holds everything it drops.
+const MAX_SKIN_IMAGES: usize = 1024;
 impl Downloader {
     pub fn new(root: std::path::PathBuf) -> Self {
         let (send, done) = std::sync::mpsc::channel();
@@ -323,6 +637,9 @@ impl Downloader {
             done,
             send,
             ready: Vec::new(),
+            queued: Default::default(),
+            images: Default::default(),
+            image_order: Default::default(),
         }
     }
     /// How the download of `url` stands, starting it the first time.
@@ -331,7 +648,8 @@ impl Downloader {
             let state = match image {
                 Some(rgba) => {
                     if key.0 == Kind::Skin {
-                        self.ready.push((skin_location(&key.1), rgba));
+                        let location = skin_location(&key.1);
+                        self.queue(location, rgba);
                     }
                     Download::Ready
                 }
@@ -370,8 +688,53 @@ impl Downloader {
         });
         Download::Pending
     }
+    /// Keeps a decoded skin for `again`, dropping the oldest past the bound.
+    fn remember(&mut self, location: String, rgba: Vec<u8>) {
+        if !self.images.contains_key(&location) {
+            self.image_order.push_back(location.clone());
+            while self.image_order.len() > MAX_SKIN_IMAGES
+                && let Some(old) = self.image_order.pop_front()
+            {
+                self.images.remove(&old);
+            }
+        }
+        self.images.insert(location, rgba);
+    }
+    /// An image off to the atlas: remembered for `again` and marked queued
+    /// so nothing uploads the same location twice.
+    fn queue(&mut self, location: String, rgba: Vec<u8>) {
+        self.remember(location.clone(), rgba.clone());
+        self.queued.insert(location.clone());
+        self.ready.push((location, rgba));
+    }
+    /// A ready skin whose atlas slot was evicted (`show_skin` answered no):
+    /// its image for upload again, from memory or the disk cache.
+    pub fn again(&mut self, location: &str) -> bool {
+        if self.queued.contains(location) {
+            return true;
+        }
+        let Some(digest) = location.strip_prefix("skins/") else {
+            return false;
+        };
+        let image = self.images.get(location).cloned().or_else(|| {
+            let file = self
+                .root
+                .join(if digest.len() > 2 { &digest[..2] } else { "xx" })
+                .join(digest);
+            let (w, h, rgba) = crate::hud::decode_bytes(&std::fs::read(&file).ok()?).ok()?;
+            process_legacy_skin(w, h, &rgba)
+        });
+        let Some(image) = image else {
+            return false;
+        };
+        self.queue(location.to_owned(), image);
+        true
+    }
     /// Skins that finished since the last call: texture id and 64x64 RGBA.
     pub fn take_ready(&mut self) -> Vec<(String, Vec<u8>)> {
+        for (location, _) in &self.ready {
+            self.queued.remove(location);
+        }
         std::mem::take(&mut self.ready)
     }
 }
@@ -452,6 +815,134 @@ pub fn sha1(data: &[u8]) -> [u8; 20] {
 
 #[cfg(test)]
 mod tests {
+    #[test]
+    fn profiles_parse_like_resolvable_profiles() {
+        use super::{NameOrId, Signature, parse_profile};
+        // A bare name is `createUnresolved`: dynamic by name, and its partial
+        // id is the name's offline UUID.
+        let p = parse_profile(&serde_json::json!("Notch"));
+        assert_eq!(p.dynamic, Some(NameOrId::Name("Notch".into())));
+        assert_eq!(p.id, horizon_protocol::crypto::offline_uuid("Notch"));
+        assert!(p.textures.is_none());
+        // A name-only compound resolves the same way.
+        let p = parse_profile(&serde_json::json!({"name": "Notch"}));
+        assert_eq!(p.dynamic, Some(NameOrId::Name("Notch".into())));
+        // An id-only compound resolves by id (int array or UUID string).
+        let id = 0x0123_4567_89ab_cdef_0123_4567_89ab_cdef_u128;
+        let ints: Vec<i64> = [
+            (id >> 96) as i32 as i64,
+            (id >> 64) as i32 as i64,
+            (id >> 32) as i32 as i64,
+            id as i32 as i64,
+        ]
+        .into();
+        let p = parse_profile(&serde_json::json!({"id": ints}));
+        assert_eq!(p.dynamic, Some(NameOrId::Id(id)));
+        let p = parse_profile(&serde_json::json!({"id": "01234567-89ab-cdef-0123-4567abcdef00"}));
+        assert_eq!(
+            p.dynamic,
+            Some(NameOrId::Id(0x0123_4567_89ab_cdef_0123_4567_abcd_ef00))
+        );
+        // Name and id but no properties is Static: it never resolves, and its
+        // default skin keys off the id.
+        let p = parse_profile(&serde_json::json!({"name": "Notch", "id": ints}));
+        assert!(p.dynamic.is_none());
+        assert_eq!(p.id, id);
+        // A `textures` property makes it Static (unsigned and signed).
+        let p = parse_profile(&serde_json::json!({
+            "properties": [{"name": "textures", "value": "v"}]
+        }));
+        assert!(p.dynamic.is_none());
+        assert_eq!(p.textures, Some(("v".into(), Signature::Unsigned)));
+        let p = parse_profile(&serde_json::json!({
+            "properties": [{"name": "textures", "value": "v", "signature": "s"}]
+        }));
+        assert_eq!(p.textures, Some(("v".into(), Signature::Signed)));
+        // Empty properties leave it dynamic.
+        let p = parse_profile(&serde_json::json!({"name": "Notch", "properties": []}));
+        assert_eq!(p.dynamic, Some(NameOrId::Name("Notch".into())));
+    }
+
+    /// `getByName` and `getProfileById` answer from the services the
+    /// discovery document names; a profile resolves through both.
+    #[test]
+    fn profiles_resolve_through_the_services() {
+        use std::io::{BufRead, BufReader, Write};
+        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+        let base = format!("http://{}", listener.local_addr().unwrap());
+        std::thread::spawn(move || {
+            let reply = |status: &str, body: &str| {
+                format!(
+                    "HTTP/1.1 {status}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
+                    body.len()
+                )
+            };
+            for stream in listener.incoming().take(3) {
+                let mut stream = stream.unwrap();
+                let mut line = String::new();
+                let mut reader = BufReader::new(stream.try_clone().unwrap());
+                reader.read_line(&mut line).unwrap();
+                while reader.read_line(&mut String::new()).unwrap() > 2 {}
+                let body = if line.contains("/users/profiles/minecraft/") {
+                    r#"{"id":"069a79f444e94726a5befca90e38aaf5","name":"Notch"}"#
+                } else if line.contains("/session/minecraft/profile/")
+                    && line.contains("unsigned=false")
+                {
+                    r#"{"id":"069a79f444e94726a5befca90e38aaf5","name":"Notch","properties":[{"name":"textures","value":"dmFsdWU=","signature":"c2ln"}]}"#
+                } else {
+                    "{}"
+                };
+                stream.write_all(reply("200 OK", body).as_bytes()).unwrap();
+            }
+        });
+        let doc = serde_json::json!({"discovery": {
+            "profiles": {"endpoints": {"getByName": {"uri": format!("{base}/users/profiles/minecraft/{{name}}")}}},
+            "session": {"endpoints": {"getProfileById": {"uri": format!("{base}/session/minecraft/profile/{{profileId}}")}}},
+        }});
+        let resolved =
+            super::resolve_profile(&super::NameOrId::Name("Notch".into()), &doc).unwrap();
+        assert_eq!(resolved.id, 0x069a_79f4_44e9_4726_a5be_fca9_0e38_aaf5);
+        assert_eq!(resolved.name, "Notch");
+        assert_eq!(
+            resolved.properties,
+            vec![(
+                "textures".to_owned(),
+                "dmFsdWU=".to_owned(),
+                Some("c2ln".to_owned())
+            )]
+        );
+        let by_id = super::resolve_profile(&super::NameOrId::Id(resolved.id), &doc).unwrap();
+        assert_eq!(by_id.name, "Notch");
+        // A discovery without `profiles`/`getByName` resolves no name.
+        let doc = serde_json::json!({"discovery": {
+            "session": {"endpoints": {"getProfileById": {"uri": format!("{base}/session/minecraft/profile/{{profileId}}")}}},
+        }});
+        assert!(super::resolve_profile(&super::NameOrId::Name("Notch".into()), &doc).is_none());
+    }
+
+    /// A skin evicted from the atlas re-uploads (`again`), once per ask.
+    #[test]
+    fn evicted_skins_upload_again() {
+        let mut d = super::Downloader::new(std::env::temp_dir().join("horizon-test-skins"));
+        d.remember("skins/abc".into(), vec![1, 2, 3]);
+        assert!(d.again("skins/abc"));
+        assert!(!d.again("skins/missing"));
+        // Once queued, more asks do not pile up uploads.
+        assert!(d.again("skins/abc"));
+        assert_eq!(
+            d.take_ready(),
+            vec![("skins/abc".to_owned(), vec![1, 2, 3])]
+        );
+        assert!(d.take_ready().is_empty());
+        assert!(d.again("skins/abc"));
+        assert_eq!(d.take_ready().len(), 1);
+        // The first upload marks the location queued too: an `again` before
+        // `take_ready` does not put the same skin in the atlas twice.
+        d.queue("skins/def".into(), vec![4]);
+        assert!(d.again("skins/def"));
+        assert_eq!(d.take_ready(), vec![("skins/def".to_owned(), vec![4])]);
+    }
+
     #[test]
     fn profile_components_supply_unsigned_head_skins() {
         let value = "eyJ0ZXh0dXJlcyI6IHsiU0tJTiI6IHsidXJsIjogImh0dHBzOi8vdGV4dHVyZXMubWluZWNyYWZ0Lm5ldC90ZXh0dXJlL2FiYzEyMyJ9fX0=";
diff --git a/crates/horizon-client/src/spans.rs b/crates/horizon-client/src/spans.rs
index ce69be8ce..33c4bb933 100644
--- a/crates/horizon-client/src/spans.rs
+++ b/crates/horizon-client/src/spans.rs
@@ -52,8 +52,9 @@ pub fn thread_cpu() -> Option<Duration> {
         Some(Duration::new(t.tv_sec as u64, t.tv_nsec as u32))
     }
     #[cfg(not(unix))]
-    None
+    horizon_threads::thread_cpu()
 }
+
 /// The frame's spans, summed by name, slowest first; clears them.
 pub fn take() -> Vec<Span> {
     let spans = SPANS.with(|s| std::mem::take(&mut *s.borrow_mut()));
@@ -135,7 +136,7 @@ mod tests {
 
     /// The thread's CPU clock moves with work done on it, not with time
     /// spent asleep.
-    #[cfg(unix)]
+    #[cfg(any(unix, all(windows, target_arch = "x86_64")))]
     #[test]
     fn thread_cpu_counts_work_not_sleep() {
         let start = super::thread_cpu().unwrap();
diff --git a/crates/horizon-client/src/sprites.rs b/crates/horizon-client/src/sprites.rs
index 6d754894a..b720c5bfd 100644
--- a/crates/horizon-client/src/sprites.rs
+++ b/crates/horizon-client/src/sprites.rs
@@ -342,10 +342,25 @@ pub(crate) fn test_frames(layer: u32, frames: Vec<Vec<u8>>, metadata: &str) -> S
     }
 }
 
+/// How many reduced copies a sprite atlas keeps: the Mipmap Levels option plus the
+/// resampling-only levels an upscaled pack needs, within what the atlas holds.
+pub(crate) fn sprite_mipmap_limit(requested: u32, size: u32, minimum: u32, available: u32) -> u32 {
+    // Only the atlas native minimum determines how many resampling-only mips to skip.
+    let upscale = (size / minimum.max(1)).max(1).ilog2();
+    requested.saturating_add(upscale).min(available - 1)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     #[test]
+    fn mipmap_option_keeps_real_16px_reductions() {
+        for levels in 0..=4 {
+            assert_eq!(sprite_mipmap_limit(levels, 32, 16, 6), levels + 1);
+            assert_eq!(sprite_mipmap_limit(levels, 16, 16, 5), levels);
+        }
+    }
+    #[test]
     fn identical_still_textures_share_a_layer() {
         let root =
             std::env::temp_dir().join(format!("horizon-sprite-share-{}", std::process::id()));
@@ -398,7 +413,7 @@ mod tests {
         assert_eq!((sprites.size, sprites.minimum_size), (32, 32));
         for level in 0..=4 {
             assert_eq!(
-                crate::gfx::sprite_mipmap_limit(level, sprites.size, sprites.minimum_size, 6),
+                sprite_mipmap_limit(level, sprites.size, sprites.minimum_size, 6),
                 level
             );
         }
@@ -408,7 +423,7 @@ mod tests {
         sprites.finish();
         assert_eq!((sprites.size, sprites.minimum_size), (32, 16));
         assert_eq!(
-            crate::gfx::sprite_mipmap_limit(0, sprites.size, sprites.minimum_size, 6),
+            sprite_mipmap_limit(0, sprites.size, sprites.minimum_size, 6),
             1
         );
     }
diff --git a/crates/horizon-client/src/stations.rs b/crates/horizon-client/src/stations.rs
index a307b35cf..14dfedb49 100644
--- a/crates/horizon-client/src/stations.rs
+++ b/crates/horizon-client/src/stations.rs
@@ -151,8 +151,12 @@ pub struct AnvilResult {
     pub repair_item_count_cost: u32,
     pub only_renaming: bool,
 }
+/// `ItemStack.isDamageableItem`: durability, and not `minecraft:unbreakable`.
 pub fn is_damageable(items: &Items, stack: &ItemStack) -> bool {
     items.get(&stack.item).is_some_and(|i| i.max_damage > 0)
+        && stack
+            .data()
+            .is_none_or(|d| d.other("minecraft:unbreakable").is_none())
 }
 fn max_damage(items: &Items, stack: &ItemStack) -> i32 {
     items.get(&stack.item).map_or(0, |i| i.max_damage as i32)
@@ -448,6 +452,7 @@ pub fn grindstone_experience(
 #[derive(Clone, Debug)]
 pub enum Smithing {
     Transform {
+        id: String,
         template: Ingredient,
         base: Ingredient,
         addition: Ingredient,
@@ -527,6 +532,7 @@ impl StationRecipes {
             );
             match v["type"].as_str().unwrap_or("") {
                 "minecraft:smithing_transform" => smithing.push(Smithing::Transform {
+                    id,
                     template: ingredient(&v["template"], items),
                     base: ingredient(&v["base"], items),
                     addition: ingredient(&v["addition"], items),
@@ -630,6 +636,7 @@ impl StationRecipes {
                     base: b,
                     addition: a,
                     result,
+                    ..
                 } => {
                     if t.test(template) && b.test(base) && a.test(addition) {
                         // SmithingTransformRecipe: transmute the base keeping its components.
diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs
index 643a604bc..6588ac32d 100644
--- a/crates/horizon-client/src/streaming.rs
+++ b/crates/horizon-client/src/streaming.rs
@@ -70,11 +70,16 @@ pub trait ChunkGenerator: Send + Sync + 'static {
         false
     }
     /// What to save of a proto chunk dropped before it became final.
-    fn saved_proto(&self, _proto: &Proto) -> Option<crate::save::SavedProto> {
+    /// A decorated proto chunk's blocks as a column, to light a finished
+    /// neighbour against (vanilla lights with neighbours at FEATURES).
+    fn light_view(&self, _proto: &Proto) -> Option<Chunk> {
+        None
+    }
+    fn saved_proto(&self, _proto: &Proto) -> Option<crate::chunk::SavedProto> {
         None
     }
     /// Put a saved proto chunk's state back onto `proto`, generated again.
-    fn restore_proto(&self, _proto: &mut Proto, _saved: crate::save::SavedProto) {}
+    fn restore_proto(&self, _proto: &mut Proto, _saved: crate::chunk::SavedProto) {}
     /// Save proto chunks decoration wrote to, so that they come back as they
     /// were: generating them again would lose those writes.
     fn save_protos(&self, _protos: &[&Proto]) {}
@@ -175,6 +180,11 @@ pub enum Done {
 }
 struct Queued {
     priority: i64,
+    /// The column the job is for and what it adds to the column's distance
+    /// (`Streaming::submit`): the priority is computed again from them when
+    /// the centre moves (`Streaming::requeue`). None for saves, which go first.
+    at: Option<(i32, i32)>,
+    bias: i64,
     order: u64,
     job: Job,
 }
@@ -207,6 +217,7 @@ struct Shared {
 }
 pub struct Streaming {
     shared: Arc<Shared>,
+    light_view: Arc<dyn Fn(&Proto) -> Option<Chunk> + Send + Sync>,
     results: mpsc::Receiver<Done>,
     threads: Vec<thread::JoinHandle<()>>,
     order: u64,
@@ -222,6 +233,9 @@ pub struct Streaming {
     /// radius it was last ranked for.
     decoration_order: DecorationOrder,
     order_area: Option<((i32, i32), i32)>,
+    /// What the queued jobs' priorities were computed from (`requeue`): the
+    /// centre, the loading screen, the band, and the extra areas.
+    queue_basis: (((i32, i32), bool, Option<Band>), Vec<((i32, i32), i32)>),
     finishing: FxHashSet<(i32, i32)>,
     decorates: bool,
     lighting: FxHashMap<(i32, i32), u64>,
@@ -531,8 +545,13 @@ impl Streaming {
                     .expect("spawn worker")
             })
             .collect();
+        let light_view = {
+            let generator = generator.clone();
+            Arc::new(move |p: &Proto| generator.light_view(p))
+        };
         Self {
             shared,
+            light_view,
             results,
             threads,
             order: 0,
@@ -544,6 +563,7 @@ impl Streaming {
             saving: 0,
             decoration_order: DecorationOrder::default(),
             order_area: None,
+            queue_basis: Default::default(),
             finishing: Default::default(),
             decorates: generator.decorates(),
             lighting: Default::default(),
@@ -648,15 +668,39 @@ impl Streaming {
         world.dirty_sections.take_column(x, z);
         world.chunks.remove(&(x, z))
     }
-    fn submit(&mut self, priority: i64, job: Job) {
+    /// Queue a job for the column `at`, nearest first: its distance (`distance`)
+    /// times four plus `bias`, which orders a column's jobs. A job without a
+    /// column (a save) goes ahead of every other.
+    fn submit(&mut self, at: Option<(i32, i32)>, bias: i64, job: Job) {
         self.order += 1;
+        let priority = at.map_or(i64::MIN, |(x, z)| self.distance(x, z) * 4 + bias);
         self.shared.queue.lock().unwrap().push(Queued {
             priority,
+            at,
+            bias,
             order: self.order,
             job,
         });
         self.shared.ready.notify_one();
     }
+    /// Rank the queued jobs again when what their priorities were computed
+    /// from changed: the centre, the extra areas, the band, or the loading
+    /// screen (ring order, `Ranges::rings`, whose values are far above the
+    /// distances used after it). Vanilla's chunk task queue follows the
+    /// current ticket levels in the same way. Without it, generation queued
+    /// while the loading screen was up waited behind every job queued after
+    /// it, and with it the decoration of the chunks around the player: at
+    /// render distance 32 nothing was decorated until every proto chunk had
+    /// been generated.
+    fn requeue(&mut self) {
+        let basis = (self.center, self.loading, self.band);
+        if self.queue_basis.0 == basis && self.queue_basis.1 == self.extra {
+            return;
+        }
+        self.queue_basis = (basis, self.extra.clone());
+        let mut queue = self.shared.queue.lock().unwrap();
+        rank_again(&mut queue, |x, z| self.distance(x, z));
+    }
     fn receive_decorated(&mut self, x: i32, z: i32, region: [Proto; 9]) {
         self.generation_scan.exhausted = false;
         self.decorating -= 1;
@@ -686,7 +730,7 @@ impl Streaming {
             self.saving += 1;
             // Ahead of every other job: a column generated again meanwhile
             // would not find them saved.
-            self.submit(i64::MIN, Job::Save(protos));
+            self.submit(None, 0, Job::Save(protos));
         }
     }
     fn receive_generated(&mut self, mut chunk: Chunk, world: &mut World) {
@@ -746,6 +790,26 @@ impl Streaming {
     fn distance(&self, x: i32, z: i32) -> i64 {
         self.ranges().priority(x, z, self.loading)
     }
+    /// The 3x3 a light job reads: the finished columns, and for a neighbour
+    /// that will not finish (past the area), its decorated proto chunk, as
+    /// vanilla lights its last FULL ring against neighbours at FEATURES.
+    fn light_region(&self, world: &World, x: i32, z: i32) -> Option<Box<Region>> {
+        let mut region: Region = Default::default();
+        for dz in 0..3 {
+            for dx in 0..3 {
+                let n = (x + dx as i32 - 1, z + dz as i32 - 1);
+                region[dz][dx] = Some(match world.chunks.get(&n) {
+                    Some(chunk) => chunk.clone(),
+                    None if !self.in_range(n.0, n.1, 1) && self.decorated.contains(&n) => {
+                        let proto = self.protos.get(&n)?.as_ref()?;
+                        Arc::new((self.light_view)(proto)?)
+                    }
+                    None => return None,
+                });
+            }
+        }
+        Some(Box::new(region))
+    }
     fn region(world: &World, x: i32, z: i32) -> Option<Box<Region>> {
         let mut region: Region = Default::default();
         for dz in 0..3 {
@@ -829,6 +893,7 @@ impl Streaming {
             return (uploads, Vec::new());
         }
         ExtraCover::refresh(&mut self.cover, &self.extra);
+        self.requeue();
         self.relight_edits(world);
         let deferred = std::mem::take(&mut self.deferred);
         let received = std::iter::from_fn(|| self.results.try_recv().ok());
@@ -866,6 +931,11 @@ impl Streaming {
                         } else {
                             apply_relighting(chunk, sections, &mut changed);
                         }
+                        // Saved unlit (at the edge of what was loaded), or its light
+                        // changed: saved again.
+                        if (first && !chunk.light_loaded) || !changed.is_empty() {
+                            world.modified.insert((x, z));
+                        }
                         chunk.lit = true;
                         if first {
                             for dz in -1..=1 {
@@ -984,7 +1054,7 @@ impl Streaming {
                     .expect("present proto");
                 self.finishing.insert((x, z));
                 self.written.remove(&(x, z));
-                self.submit(self.distance(x, z) * 4, Job::Finish(proto));
+                self.submit(Some((x, z)), 0, Job::Finish(proto));
             }
         }
         // Decorate chunks whose 3x3 proto neighbourhood is available, in
@@ -1052,7 +1122,7 @@ impl Streaming {
                 w.0 = self.decoration_order.rank_or_append(w.2, w.3);
             }
             wanted.sort_unstable();
-            for (_, d, x, z) in wanted {
+            for (_, _, x, z) in wanted {
                 if self.decorating >= workers * 2 {
                     break;
                 }
@@ -1091,7 +1161,7 @@ impl Streaming {
                     Err(_) => continue,
                 };
                 self.decorating += 1;
-                self.submit(d * 4 + 1, Job::Decorate(x, z, region));
+                self.submit(Some((x, z)), 1, Job::Decorate(x, z, region));
             }
         }
         self.schedule_generation(world, workers);
@@ -1102,7 +1172,7 @@ impl Streaming {
                 world.dirty_light.remove(&(x, z));
                 continue;
             }
-            let Some(region) = Self::region(world, x, z) else {
+            let Some(region) = self.light_region(world, x, z) else {
                 continue;
             };
             world.dirty_light.remove(&(x, z));
@@ -1111,7 +1181,8 @@ impl Streaming {
             self.light_snapshots
                 .insert((x, z), self.light_edit_sequence);
             self.submit(
-                self.distance(x, z) * 4 + 1,
+                Some((x, z)),
+                1,
                 Job::Light(x, z, region, self.sequence, self.sky_light),
             );
         }
@@ -1183,7 +1254,8 @@ impl Streaming {
                 self.sequence += 1;
                 self.meshing.insert((x, sy, z), self.sequence);
                 self.submit(
-                    self.distance(x, z) * 4 + if first { 2 } else { 0 },
+                    Some((x, z)),
+                    if first { 2 } else { 0 },
                     Job::Mesh(
                         x,
                         sy,
@@ -1222,9 +1294,9 @@ impl Streaming {
             loading: self.loading,
         };
         if let Some(wanted) = self.generation_scan.candidates(input, workers * 3) {
-            for (d, x, z) in wanted {
+            for (_, x, z) in wanted {
                 self.generating.insert((x, z));
-                self.submit(d * 4, Job::Generate(x, z));
+                self.submit(Some((x, z)), 0, Job::Generate(x, z));
             }
         }
     }
@@ -1381,6 +1453,14 @@ impl Streaming {
     pub fn band(&self) -> Option<Band> {
         self.band
     }
+    /// Rank the chunks `/forceload add` over chunks `(x0, z0)..=(x1, z1)`
+    /// decorates in vanilla's order (`forced_order`), after every chunk
+    /// ranked before.
+    pub fn rank_forced(&mut self, x0: i32, z0: i32, x1: i32, z1: i32) {
+        for (x, z) in horizon_world::worldgen::decoration_order::forced_order(x0, z0, x1, z1) {
+            self.decoration_order.rank_or_append(x, z);
+        }
+    }
     /// Generate, light and keep the chunks of `band` (none: stop), and let
     /// go of what earlier bands held as it falls out of range. The chunks a
     /// band reaches are ranked for decoration row by row, as they first come
@@ -1424,7 +1504,7 @@ impl Streaming {
                 counts[1] += 1;
             } else {
                 counts[2] += 1;
-                if Self::region(world, key.0, key.1).is_some() {
+                if self.light_region(world, key.0, key.1).is_some() {
                     world.dirty_light.insert(key);
                 }
             }
@@ -1738,10 +1818,78 @@ fn section_indexes(mut bits: u32) -> impl Iterator<Item = i32> {
         })
     })
 }
+/// The queued jobs' priorities computed again from each one's column
+/// `distance` (`Streaming::submit`).
+fn rank_again(queue: &mut BinaryHeap<Queued>, distance: impl Fn(i32, i32) -> i64) {
+    if queue.is_empty() {
+        return;
+    }
+    let mut jobs = std::mem::take(queue).into_vec();
+    for job in &mut jobs {
+        if let Some((x, z)) = job.at {
+            job.priority = distance(x, z) * 4 + job.bias;
+        }
+    }
+    *queue = BinaryHeap::from(jobs);
+}
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[test]
+    fn queued_jobs_follow_the_centre_and_the_loading_screen() {
+        let forced = HashSet::new();
+        let ranges = |center| Ranges {
+            center,
+            radius: 32,
+            extra: &[],
+            forced: &forced,
+            cover: None,
+            band: None,
+        };
+        let generate = |x, z, priority, order| Queued {
+            priority,
+            at: Some((x, z)),
+            bias: 0,
+            order,
+            job: Job::Generate(x, z),
+        };
+        let loading = ranges((0, 0));
+        let queued = || {
+            BinaryHeap::from(vec![
+                // Queued while the loading screen was up: ring order.
+                generate(3, 1, loading.priority(3, 1, true) * 4, 1),
+                // Queued after it closed: plain distances, far below any ring past the first.
+                generate(20, 0, loading.priority(20, 0, false) * 4, 2),
+                Queued {
+                    priority: i64::MIN,
+                    at: None,
+                    bias: 0,
+                    order: 3,
+                    job: Job::Save(Vec::new()),
+                },
+            ])
+        };
+        let pops = |mut queue: BinaryHeap<Queued>| {
+            std::iter::from_fn(move || queue.pop())
+                .map(|q| q.at)
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(
+            pops(queued()),
+            [None, Some((20, 0)), Some((3, 1))],
+            "the stale order"
+        );
+        let mut queue = queued();
+        rank_again(&mut queue, |x, z| loading.priority(x, z, false));
+        assert_eq!(pops(queue), [None, Some((3, 1)), Some((20, 0))]);
+        // The player moved: the job near the new centre goes first.
+        let mut queue = BinaryHeap::from(vec![generate(3, 1, 0, 1), generate(20, 0, 1, 2)]);
+        let moved = ranges((19, 0));
+        rank_again(&mut queue, |x, z| moved.priority(x, z, false));
+        assert_eq!(queue.pop().and_then(|q| q.at), Some((20, 0)));
+    }
+
     #[test]
     fn view_distance_is_vanillas_shape() {
         // ChunkTrackingView.isInViewDistance at render distance 12: a column
diff --git a/crates/horizon-client/src/structure_blocks.rs b/crates/horizon-client/src/structure_blocks.rs
index f77696277..8183b415a 100644
--- a/crates/horizon-client/src/structure_blocks.rs
+++ b/crates/horizon-client/src/structure_blocks.rs
@@ -9,7 +9,7 @@ use horizon_world::{
 };
 use std::{
     path::Path,
-    sync::{Arc, OnceLock},
+    sync::{Arc, Mutex},
 };
 
 /// The `custom_data` key holding an exploration map's search until the game
@@ -63,6 +63,12 @@ pub fn loot_item_with_components(s: &horizon_world::loot::LootStack) -> ItemStac
     if let Some(level) = s.ominous_amplifier.filter(|l| *l > 0) {
         item.data_mut().ominous_amplifier = Some(level.clamp(0, 4) as u8);
     }
+    // set_stew_effect's `suspicious_stew_effects`.
+    for (effect, duration) in &s.stew_effects {
+        item.data_mut()
+            .stew_effects
+            .push((Arc::from(effect.as_str()), *duration));
+    }
     item
 }
 
@@ -108,11 +114,13 @@ pub fn has_pending_map(item: &ItemStack) -> bool {
     })
 }
 
-static LOOT: OnceLock<Option<Arc<LootData>>> = OnceLock::new();
+/// None until `loot_data` runs; `Some(None)` when the tables failed to load.
+static LOOT: Mutex<Option<Option<Arc<LootData>>>> = Mutex::new(None);
 
 /// Loot data of the resource root, loaded once per process.
 pub fn loot_data(root: &Path) -> Option<Arc<LootData>> {
-    LOOT.get_or_init(|| match LootData::load(root) {
+    let mut loot = LOOT.lock().unwrap_or_else(|e| e.into_inner());
+    loot.get_or_insert_with(|| match LootData::load(root) {
         Ok(data) => Some(Arc::new(data)),
         Err(e) => {
             log::warn!("Horizon: loot tables unavailable, structure containers stay empty: {e}");
@@ -124,7 +132,16 @@ pub fn loot_data(root: &Path) -> Option<Arc<LootData>> {
 
 /// The loot data `loot_data` loaded, if it ran.
 pub fn loaded_loot_data() -> Option<Arc<LootData>> {
-    LOOT.get().cloned().flatten()
+    LOOT.lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .clone()
+        .flatten()
+}
+
+/// Let go of the loot data: for a preload no world used
+/// (game/world_loading.rs). The next `loot_data` loads it again.
+pub fn forget_loot_data() {
+    *LOOT.lock().unwrap_or_else(|e| e.into_inner()) = None;
 }
 
 /// `RandomizableContainer.unpackLootTable` of a container at `pos`: `table`
@@ -179,23 +196,27 @@ fn text(nbt: &Compound, key: &str) -> Option<String> {
 
 /// The client block entity for one of a chunk's generated block entities,
 /// before a container's loot is unpacked: `StructureTemplate.placeInWorld`
-/// hands the template's block entity NBT to the level's block entity.
+/// hands the template's block entity NBT to `loadWithComponents`, which is
+/// what a chunk load does with a saved one.
 fn generated_block_entity(block: &str, nbt: &Compound) -> Option<BlockEntity> {
-    let mut entity = BlockEntity::for_block(block)?;
-    match &mut entity {
-        // MonsterRoomFeature and the structures' setEntityId.
-        BlockEntity::Spawner(s) => {
-            **s = crate::mobs::spawner::Spawner::load(&Tag::Compound(nbt.clone()));
-        }
-        BlockEntity::TrialSpawner(s) => {
-            **s = crate::mobs::trial_spawner::TrialSpawner::load(&Tag::Compound(nbt.clone()));
-        }
-        BlockEntity::Vault(v) => **v = crate::vault::Vault::load(&Tag::Compound(nbt.clone())),
-        // BannerBlockEntity.loadAdditional: the End cities' black triangles.
-        BlockEntity::Banner(b) => *b = crate::save::decode_banner(&Tag::Compound(nbt.clone())),
-        _ => {}
+    let fallback = BlockEntity::for_block(block)?;
+    let mut tag = nbt.clone();
+    // RandomizableContainer.tryLoadLootTable: with a table the items are not read.
+    if text(&tag, "LootTable").is_some() {
+        tag.remove(&JavaString::from("Items"));
     }
-    Some(entity)
+    // Programmatic block entities (and a template that saved none) carry no id.
+    if !tag.contains_key(&JavaString::from("id")) {
+        tag.insert("id".into(), Tag::String(fallback.id().into()));
+    }
+    for axis in ["x", "y", "z"] {
+        tag.insert(axis.into(), Tag::Int(0));
+    }
+    // A saved kind the client cannot decode keeps the block's own entity.
+    Some(
+        crate::save::decode_block_entity(&Tag::Compound(tag))
+            .map_or(fallback, |(_, entity)| entity),
+    )
 }
 
 /// Client block entities for the generated block entities of a chunk, and the
@@ -236,6 +257,23 @@ mod tests {
     use super::*;
     use horizon_world::loot::{ExplorationMap, LootStack};
 
+    #[test]
+    fn generated_end_gateway_keeps_its_exit() {
+        let Tag::Compound(nbt) = Tag::compound([
+            ("exit_portal", Tag::IntArray(vec![100, 50, 0])),
+            ("ExactTeleport", Tag::Byte(1)),
+        ]) else {
+            unreachable!()
+        };
+        let Some(BlockEntity::EndGateway(g)) =
+            generated_block_entity("minecraft:end_gateway", &nbt)
+        else {
+            panic!("gateway");
+        };
+        assert_eq!(g.exit_portal, Some([100, 50, 0]));
+        assert!(g.exact_teleport);
+    }
+
     #[test]
     fn placed_chest_loot_keeps_its_enchantments_and_potions() {
         let stack =
@@ -248,6 +286,7 @@ mod tests {
                 map: false,
                 exploration: None,
                 ominous_amplifier: None,
+                stew_effects: Vec::new(),
             };
         // An End city chest's enchant_with_levels roll.
         let boots = loot_item_with_components(&stack(
@@ -309,6 +348,7 @@ mod tests {
                 "zoom": 1
             })))),
             ominous_amplifier: None,
+            stew_effects: Vec::new(),
         };
         let mut item = loot_item(&stack);
         assert!(has_pending_map(&item));
diff --git a/crates/horizon-client/src/terrain.wgsl b/crates/horizon-client/src/terrain.wgsl
index c0cf44bb5..3aea6fc1a 100644
--- a/crates/horizon-client/src/terrain.wgsl
+++ b/crates/horizon-client/src/terrain.wgsl
@@ -258,7 +258,7 @@ fn sky_along_ray(d: vec3<f32>) -> vec3<f32> {
 }
 
 // rendertype_lines.vsh: screen-space stroke and camera-space depth separation.
-fn outline_clip(vertex: u32, start: vec3<f32>, end: vec3<f32>) -> vec4<f32> {
+fn outline_clip(vertex: u32, start: vec3<f32>, end: vec3<f32>, width: f32) -> vec4<f32> {
     let position = select(start, end, vertex >= 2u);
     let normal = normalize(end - start);
     let view_shrink = 1.0 - 1.0 / 256.0;
@@ -268,7 +268,7 @@ fn outline_clip(vertex: u32, start: vec3<f32>, end: vec3<f32>) -> vec4<f32> {
     let ndc2 = line_end.xyz / line_end.w;
     let screen = globals.outline_params.xy;
     let direction = normalize((ndc2.xy - ndc1.xy) * screen);
-    var offset = vec2(-direction.y, direction.x) * globals.outline_params.z / screen;
+    var offset = vec2(-direction.y, direction.x) * width / screen;
     if offset.x < 0.0 { offset = -offset; }
     if vertex % 2u != 0u { offset = -offset; }
     return vec4((ndc1 + vec3(offset, 0.0)) * line_start.w, line_start.w);
@@ -277,18 +277,22 @@ struct LineOut {
     @builtin(position) clip: vec4<f32>,
     @location(0) spherical: f32,
     @location(1) cylindrical: f32,
+    @location(2) color: vec4<f32>,
 }
 @vertex fn vs_line(@builtin(vertex_index) vertex: u32,
-    @location(0) start: vec3<f32>, @location(1) end: vec3<f32>) -> LineOut {
+    @location(0) start: vec3<f32>, @location(1) end: vec3<f32>,
+    @location(2) argb: vec4<f32>, @location(3) width: f32) -> LineOut {
     let position = select(start, end, vertex >= 2u);
     var out: LineOut;
-    out.clip = outline_clip(vertex, start, end);
+    out.clip = outline_clip(vertex, start, end, width);
     out.spherical = length(position);
     out.cylindrical = max(length(position.xz), abs(position.y));
+    // ARGB in a little-endian u32 reads as B, G, R, A.
+    out.color = argb.zyxw;
     return out;
 }
 @fragment fn fs_line(in: LineOut) -> @location(0) vec4<f32> {
-    return apply_fog(vec4(0.0, 0.0, 0.0, 0.4), in.spherical, in.cylindrical);
+    return apply_fog(in.color, in.spherical, in.cylindrical);
 }
 // Gizmo lines (rendertype_lines with a per-vertex colour and LineWidth in
 // pixels; no layering transform).
diff --git a/crates/horizon-client/src/title.rs b/crates/horizon-client/src/title.rs
index 87bd05fd0..b2fcfe8f4 100644
--- a/crates/horizon-client/src/title.rs
+++ b/crates/horizon-client/src/title.rs
@@ -1,6 +1,7 @@
 //! Title, world selection and world creation screens (TitleScreen,
 //! SelectWorldScreen, CreateWorldScreen layouts), drawn as HUD quads.
 use crate::{
+    game_rules_screen::{Exit, RulesScreen},
     hud::{HudAtlas, HudBatch, rgba},
     lang,
     save::Level,
@@ -13,10 +14,12 @@ use std::{
 };
 
 mod create_world;
+mod flat;
 #[cfg(test)]
 mod tests;
 pub mod world_management;
 pub use create_world::{DIFFICULTIES, WorldOptions};
+pub use flat::{FlatLayer, FlatSettings, State as FlatEditor};
 
 /// SelectWorldScreen's `HeaderAndFooterLayout(8 + 9 + 8 + 20 + 4, 60)`.
 const LIST_TOP: f32 = 49.0;
@@ -101,6 +104,16 @@ pub enum Mode {
         return_to: Box<Mode>,
     },
     Multiplayer(crate::multiplayer::Screen),
+    /// CreateFlatWorldScreen over Create New World: the fields that screen
+    /// keeps and the superflat editor on top of them.
+    CreateFlat {
+        name: String,
+        seed: String,
+        creative: bool,
+        focus: u8,
+        options: WorldOptions,
+        flat: flat::State,
+    },
 }
 #[derive(Clone, Debug, PartialEq)]
 pub enum Action {
@@ -128,6 +141,8 @@ pub struct Title {
     /// Direct Connection's address, synchronized with `options.txt`'s `lastServer`.
     pub last_server: String,
     pub saves: PathBuf,
+    /// The prepared resource root: the flat preset list and block registry.
+    resources: PathBuf,
     pub started: std::time::Instant,
     search: String,
     search_focused: bool,
@@ -144,6 +159,8 @@ pub struct Title {
     splash: Option<String>,
     /// The saves listed for Home, re-read every couple of seconds.
     recent: std::cell::RefCell<Option<(std::time::Instant, Vec<WorldEntry>)>>,
+    /// WorldCreationGameRulesScreen, over Create New World while it is open.
+    rules: RefCell<Option<RulesScreen>>,
 }
 pub(crate) struct Button {
     x: f32,
@@ -231,6 +248,7 @@ impl Title {
             mode,
             last_server: String::new(),
             saves,
+            resources: resources.to_owned(),
             started: now,
             search: String::new(),
             search_focused: false,
@@ -252,6 +270,7 @@ impl Title {
                 (today.month(), today.day()),
             ),
             recent: std::cell::RefCell::new(None),
+            rules: RefCell::new(None),
         }
     }
     /// Vanilla bypasses the selector when there are no saves.
@@ -316,6 +335,64 @@ impl Title {
             self.return_to_list(None);
         }
     }
+    /// A press on the superflat screens: their list, share box or buttons.
+    fn flat_click(&mut self, x: f32, y: f32, size: (f32, f32), hit: Option<u8>) {
+        match hit {
+            Some(70) => {
+                if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+                    flat.remove_selected();
+                }
+            }
+            Some(71) => {
+                if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+                    flat.open_presets();
+                }
+            }
+            Some(72) => self.close_flat(true),
+            Some(73) => self.close_flat(false),
+            Some(74) => {
+                if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+                    flat.apply_share();
+                }
+            }
+            Some(75) => {
+                if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+                    flat.back_to_layers();
+                }
+            }
+            None => {
+                if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+                    flat::click(flat, (x, y), size);
+                }
+            }
+            _ => {}
+        }
+    }
+    /// Return to Create New World, keeping (`apply`) or dropping the layers.
+    fn close_flat(&mut self, apply: bool) {
+        let mode = std::mem::replace(&mut self.mode, Mode::Main);
+        if let Mode::CreateFlat {
+            name,
+            seed,
+            creative,
+            focus,
+            mut options,
+            flat,
+        } = mode
+        {
+            if apply {
+                options.flat = true;
+                options.flat_settings = Some(flat.settings);
+            }
+            self.mode = Mode::Create {
+                name,
+                seed,
+                creative,
+                focus,
+                options,
+            };
+        }
+    }
     fn matches_search(&self, world: &WorldEntry) -> bool {
         let filter = self.search.to_lowercase();
         world.name.to_lowercase().contains(&filter) || world.folder.to_lowercase().contains(&filter)
@@ -360,9 +437,16 @@ impl Title {
     }
     /// The pointer moved with the button held (`mouseDragged`).
     pub fn drag(&mut self, cursor: (f32, f32), size: (f32, f32)) {
+        if let Some(rules) = self.rules.get_mut() {
+            return rules.drag(cursor.1, size.1.ceil());
+        }
         if let Mode::Multiplayer(screen) = &mut self.mode {
             return screen.drag(cursor.1, size);
         }
+        if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+            flat::drag(flat, cursor, size);
+            return;
+        }
         if let Mode::Select { worlds, .. } = &self.mode {
             let (top, bottom, _, content) = self.world_list(worlds, size);
             let mut scroll = self.scroll.get();
@@ -372,17 +456,30 @@ impl Title {
     }
     /// The button was released (`onRelease`).
     pub fn release(&mut self) {
+        if let Some(rules) = self.rules.get_mut() {
+            rules.release();
+        }
         if let Mode::Multiplayer(screen) = &mut self.mode {
             screen.release();
         }
+        if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+            flat::release(flat);
+        }
         self.scroll.get_mut().release();
     }
     /// Mouse wheel over the classic world and server lists.
     pub fn scroll_worlds(&mut self, delta: f32, cursor: (f32, f32), size: (f32, f32)) {
+        if let Some(rules) = self.rules.get_mut() {
+            return rules.wheel(delta, size.1.ceil());
+        }
         if let Mode::Multiplayer(screen) = &mut self.mode {
             screen.wheel(delta, cursor, size);
             return;
         }
+        if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+            flat::wheel(flat, delta, cursor, size);
+            return;
+        }
         let Mode::Select { worlds, .. } = &self.mode else {
             return;
         };
@@ -566,6 +663,10 @@ impl Title {
         folder
     }
     fn buttons(&self, w: f32, h: f32) -> Vec<Button> {
+        // The game rules draw and press their own.
+        if self.rules.borrow().is_some() {
+            return Vec::new();
+        }
         let (w, h) = (w.ceil(), h.ceil());
         let b = |x: f32, y: f32, w: f32, label: &str, enabled: bool, id: u8| Button {
             x,
@@ -703,6 +804,7 @@ impl Title {
             Mode::Create {
                 creative, options, ..
             } => create_world::buttons(w, h, *creative, options),
+            Mode::CreateFlat { flat, .. } => flat::buttons(w, h, flat),
             Mode::Edit { world, name, .. } => {
                 let x = (w / 2.0).floor() - 100.0;
                 let top = edit_top(h);
@@ -814,6 +916,9 @@ impl Title {
         hide_splash: bool,
     ) {
         let (w, h) = (batch.width.ceil(), batch.height.ceil());
+        if let Some(rules) = self.rules.borrow_mut().as_mut() {
+            return rules.draw(batch, atlas, cursor);
+        }
         match &self.mode {
             Mode::Main => {
                 // LogoRenderer: the logo's top 44 of 64 rows, then the edition
@@ -1022,6 +1127,7 @@ impl Title {
                 options,
                 ..
             } => self.draw_create(atlas, batch, cursor, name, seed, *focus, options),
+            Mode::CreateFlat { flat, .. } => flat::draw(self, atlas, batch, cursor, flat),
             Mode::Edit { name, focused, .. } => {
                 crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false);
                 centered(
@@ -1207,6 +1313,10 @@ impl Title {
     /// Navigation buttons can return `Action::None` while still sounding.
     pub fn click(&mut self, x: f32, y: f32, size: (f32, f32)) -> (Action, bool) {
         self.remember_direct_address();
+        // The game rules take the press in `press_rules`, which has the atlas.
+        if self.rules.get_mut().is_some() {
+            return (Action::None, false);
+        }
         let (w, h) = (size.0.ceil(), size.1.ceil());
         // MenuTabBar: a new tab clears the focus and clicks.
         if let Mode::Create { focus, options, .. } = &mut self.mode
@@ -1224,6 +1334,10 @@ impl Title {
             .into_iter()
             .find(|b| b.enabled && x >= b.x && x < b.x + b.w && y >= b.y && y < b.y + 20.0)
             .map(|b| b.id);
+        if matches!(self.mode, Mode::CreateFlat { .. }) {
+            self.flat_click(x, y, (w, h), hit);
+            return (Action::None, hit.is_some());
+        }
         let action = self.click_action(x, y, (w, h), hit);
         // World list selection is silent; launching its selected entry sounds.
         let sound = hit.is_some() || matches!(action, Action::Play { .. });
@@ -1387,6 +1501,32 @@ impl Title {
                 self.mode = *return_to.clone();
                 Action::None
             }
+            // CreateWorldScreen.openGameRulesScreen over a copy of the rules.
+            (Mode::Create { options, .. }, Some(29)) => {
+                *self.rules.get_mut() = Some(RulesScreen::for_creation(&options.rules));
+                Action::None
+            }
+            (
+                Mode::Create {
+                    name,
+                    seed,
+                    creative,
+                    focus,
+                    options,
+                },
+                Some(26),
+            ) => {
+                let flat = flat::State::new(&self.resources, options.flat_settings.clone());
+                self.mode = Mode::CreateFlat {
+                    name: name.clone(),
+                    seed: seed.clone(),
+                    creative: *creative,
+                    focus: *focus,
+                    options: options.clone(),
+                    flat,
+                };
+                Action::None
+            }
             (
                 Mode::Create {
                     creative, options, ..
@@ -1410,6 +1550,9 @@ impl Title {
     }
     /// The focused text field, its id and maximum length (copy and paste).
     pub fn focused_field(&mut self) -> Option<(crate::clipboard::FieldId, &mut String, usize)> {
+        if self.rules.get_mut().is_some() {
+            return None;
+        }
         match &mut self.mode {
             Mode::Multiplayer(screen) => screen.focused_text(),
             mode => caret_field(mode, self.search_focused, &mut self.search),
@@ -1417,10 +1560,18 @@ impl Title {
     }
     /// Whether the focused field edits at its cursor.
     pub fn has_caret_field(&mut self) -> bool {
+        // The game rules' boxes edit themselves (`edit_field`).
+        if let Some(rules) = self.rules.get_mut() {
+            return rules.typing();
+        }
         caret_field(&mut self.mode, self.search_focused, &mut self.search).is_some()
     }
     /// Edit the focused field through its `EditBox`; false when there is none.
     fn edit_field(&mut self, f: impl FnOnce(&mut crate::ui::EditBox)) -> bool {
+        if let Some(rules) = self.rules.get_mut() {
+            rules.edit(f);
+            return rules.typing();
+        }
         let Some((id, value, max)) =
             caret_field(&mut self.mode, self.search_focused, &mut self.search)
         else {
@@ -1479,6 +1630,9 @@ impl Title {
         shift: bool,
     ) {
         let (w, h) = (size.0.ceil(), size.1.ceil());
+        if self.rules.get_mut().is_some() {
+            return;
+        }
         let Some(rect @ [fx, fy, fw, fh]) = self.focused_rect((w, h)) else {
             return;
         };
@@ -1491,6 +1645,9 @@ impl Title {
     }
     /// The pointer moved with the button held (`EditBox.onDrag`).
     pub fn drag_field(&mut self, atlas: &HudAtlas, x: f32) {
+        if self.rules.get_mut().is_some() {
+            return;
+        }
         if let Some(field) = caret_field(&mut self.mode, self.search_focused, &mut self.search) {
             self.caret.get_mut().drag(atlas, field, x);
         }
@@ -1527,6 +1684,9 @@ impl Title {
         }
     }
     pub fn tab(&mut self) {
+        if self.rules.get_mut().is_some() {
+            return;
+        }
         if let Mode::Edit { focused, .. } = &mut self.mode {
             *focused = !*focused;
         }
@@ -1576,7 +1736,37 @@ impl Title {
         }
         outcome
     }
+    /// A left press on the game rules (they need the atlas for text): whether
+    /// it lands on a button, for its sound.
+    pub fn press_rules(&mut self, atlas: &HudAtlas, cursor: (f32, f32), size: (f32, f32)) -> bool {
+        let size = (size.0.ceil(), size.1.ceil());
+        let Some(rules) = self.rules.get_mut() else {
+            return false;
+        };
+        let sound = rules.clicks_button(atlas, cursor, size);
+        let exit = rules.click(atlas, cursor, size);
+        if let Some(exit) = exit {
+            self.close_rules(exit);
+        }
+        sound
+    }
+    /// WorldCreationGameRulesScreen's exit callback: Done keeps the edited
+    /// rules (`setGameRules`), Cancel drops them.
+    fn close_rules(&mut self, exit: Exit) {
+        *self.rules.get_mut() = None;
+        if let (Exit::Apply(changes), Mode::Create { options, .. }) = (exit, &mut self.mode) {
+            for (name, value) in changes {
+                options.rules.set(name, value);
+            }
+        }
+    }
     pub fn escape(&mut self) {
+        if let Some(rules) = self.rules.get_mut() {
+            if let Some(exit) = rules.escape() {
+                self.close_rules(exit);
+            }
+            return;
+        }
         self.remember_direct_address();
         if let Mode::Multiplayer(screen) = &mut self.mode
             && !screen.escape(&self.saves)
@@ -1590,6 +1780,16 @@ impl Title {
                 self.return_to_list(Some(&folder));
             }
             Mode::Error { return_to, .. } => self.mode = *return_to.clone(),
+            Mode::CreateFlat { .. } => {
+                if matches!(&self.mode, Mode::CreateFlat { flat, .. } if flat.page == flat::Page::Presets)
+                {
+                    if let Mode::CreateFlat { flat, .. } = &mut self.mode {
+                        flat.back_to_layers();
+                    }
+                } else {
+                    self.close_flat(false);
+                }
+            }
             Mode::Create { .. } => self.cancel_create(),
             _ => self.mode = Mode::Main,
         }
@@ -1618,6 +1818,7 @@ const SEARCH: crate::clipboard::FieldId = ("world.search", 0);
 const EDIT_NAME: crate::clipboard::FieldId = ("world.edit-name", 0);
 const WORLD_NAME: crate::clipboard::FieldId = ("world.name", 0);
 const WORLD_SEED: crate::clipboard::FieldId = ("world.seed", 0);
+const FLAT_SHARE: crate::clipboard::FieldId = ("world.flat-share", 0);
 /// The focused field of the world screens and the server screens: the list's
 /// search, a world name or seed, or Add Server, Direct Connection and Join a
 /// Friend.
@@ -1641,6 +1842,9 @@ fn caret_field<'a>(
             _ => None,
         },
         Mode::Multiplayer(screen) => screen.focused_text(),
+        Mode::CreateFlat { flat, .. } if flat.page == flat::Page::Presets && flat.share_focused => {
+            Some((FLAT_SHARE, &mut flat.share, 1230))
+        }
         _ => None,
     }
 }
diff --git a/crates/horizon-client/src/title/create_world.rs b/crates/horizon-client/src/title/create_world.rs
index a2fa6b8ce..c0611f0d5 100644
--- a/crates/horizon-client/src/title/create_world.rs
+++ b/crates/horizon-client/src/title/create_world.rs
@@ -32,8 +32,12 @@ pub struct WorldOptions {
     pub commands: Option<bool>,
     /// The Superflat world preset instead of Default.
     pub flat: bool,
+    /// CreateFlatWorldScreen's layers and biome, kept with the world type.
+    pub flat_settings: Option<super::flat::FlatSettings>,
     pub structures: bool,
     pub bonus_chest: bool,
+    /// `getGameRules`: the Game Rules screen's values, saved with the world.
+    pub rules: crate::gamerules::GameRules,
 }
 impl Default for WorldOptions {
     fn default() -> Self {
@@ -43,8 +47,10 @@ impl Default for WorldOptions {
             difficulty: 2,
             commands: None,
             flat: false,
+            flat_settings: None,
             structures: true,
             bonus_chest: false,
+            rules: crate::gamerules::GameRules::default(),
         }
     }
 }
@@ -64,8 +70,13 @@ impl WorldOptions {
                 .unwrap_or(2),
             commands: Some(commands),
             flat: generation.flat,
+            flat_settings: generation
+                .flat
+                .then(|| super::flat::FlatSettings::from_world(dir))
+                .flatten(),
             structures: generation.structures,
             bonus_chest: generation.bonus_chest,
+            rules: crate::gamerules::GameRules::load(dir),
             ..Self::default()
         }
     }
@@ -88,6 +99,12 @@ impl WorldOptions {
             bonus_chest: self.bonus_chest(),
         }
     }
+    /// The custom layers, as `write_world_gen_settings_with` takes them.
+    pub fn flat_settings(&self) -> Option<horizon_world::nbt::Tag> {
+        self.flat_settings
+            .as_ref()
+            .map(super::flat::FlatSettings::to_tag)
+    }
     /// A press on one of the open tab's cycle buttons or switches.
     pub(super) fn press(&mut self, id: u8, creative: &mut bool) {
         match id {
@@ -101,7 +118,13 @@ impl WorldOptions {
             }
             23 => self.difficulty = (self.difficulty + 1) % DIFFICULTIES.len(),
             24 => self.commands = Some(!self.commands(*creative)),
-            25 => self.flat = !self.flat,
+            25 => {
+                self.flat = !self.flat;
+                if self.flat {
+                    // setWorldType starts the generator from the flat preset.
+                    self.flat_settings = Some(super::flat::FlatSettings::default());
+                }
+            }
             27 => self.structures = !self.structures,
             28 => self.bonus_chest = !self.bonus_chest,
             _ => {}
@@ -243,13 +266,13 @@ pub(super) fn buttons(w: f32, h: f32, creative: bool, o: &WorldOptions) -> Vec<B
                 true,
                 25,
             ),
-            // Horizon has no preset editor (CreateFlatWorldScreen) yet.
+            // CreateFlatWorldScreen: only a flat generator has a preset editor.
             b(
                 gx + 160.0,
                 gy,
                 150.0,
                 tr("selectWorld.customizeType"),
-                false,
+                o.flat,
                 26,
             ),
             // SwitchGrid: 44-wide value-only buttons at the grid's right.
@@ -263,7 +286,7 @@ pub(super) fn buttons(w: f32, h: f32, creative: bool, o: &WorldOptions) -> Vec<B
                 28,
             ),
         ],
-        // Game rules, experiments and data packs have no screens yet.
+        // Experiments and data packs have no screens yet.
         _ => [
             "selectWorld.gameRules",
             "selectWorld.experiments",
@@ -277,7 +300,7 @@ pub(super) fn buttons(w: f32, h: f32, creative: bool, o: &WorldOptions) -> Vec<B
                 gy + 28.0 * i as f32,
                 210.0,
                 tr(key),
-                false,
+                i == 0,
                 29 + i as u8,
             )
         })
diff --git a/crates/horizon-client/src/title/flat.rs b/crates/horizon-client/src/title/flat.rs
new file mode 100644
index 000000000..506064344
--- /dev/null
+++ b/crates/horizon-client/src/title/flat.rs
@@ -0,0 +1,884 @@
+//! CreateFlatWorldScreen and PresetFlatWorldScreen: the Superflat layer list,
+//! the preset chooser and the settings they hand back to Create New World.
+use super::{Button, Title};
+use crate::{
+    hud::{HudAtlas, HudBatch, rgba},
+    lang,
+    text::{Text, format_translation},
+    ui,
+};
+use horizon_world::nbt::Tag;
+use serde_json::Value;
+use std::{collections::BTreeSet, path::Path};
+
+/// DimensionType.Y_SIZE: the most blocks a flat generator takes.
+const Y_SIZE: i32 = 4064;
+/// The list's row width (ObjectSelectionList.getRowWidth).
+const ROW_WIDTH: f32 = 220.0;
+/// The header row above the layers.
+const HEADER: f32 = 14.0;
+/// A layer or preset row.
+const LAYER_ROW: f32 = 20.0;
+const PRESET_ROW: f32 = 24.0;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct FlatLayer {
+    /// A block id such as `minecraft:dirt`.
+    pub block: String,
+    /// How many blocks tall this layer is (0..=4064).
+    pub height: i32,
+}
+
+/// FlatLevelGeneratorSettings: the layers (bottom to top), the biome and the
+/// decorations CreateFlatWorldScreen edits.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct FlatSettings {
+    pub biome: String,
+    pub features: bool,
+    pub lakes: bool,
+    pub layers: Vec<FlatLayer>,
+    pub structure_overrides: Vec<String>,
+}
+impl Default for FlatSettings {
+    fn default() -> Self {
+        // worldgen/world_preset/flat.json's overworld.
+        Self {
+            biome: "minecraft:plains".into(),
+            features: false,
+            lakes: false,
+            layers: vec![
+                FlatLayer {
+                    block: "minecraft:bedrock".into(),
+                    height: 1,
+                },
+                FlatLayer {
+                    block: "minecraft:dirt".into(),
+                    height: 2,
+                },
+                FlatLayer {
+                    block: "minecraft:grass_block".into(),
+                    height: 1,
+                },
+            ],
+            structure_overrides: vec!["minecraft:strongholds".into(), "minecraft:villages".into()],
+        }
+    }
+}
+impl FlatSettings {
+    /// A saved world's flat generator settings, for Re-Create.
+    pub fn from_world(dir: &Path) -> Option<Self> {
+        let settings = crate::save::world_gen_settings(dir)?;
+        let generator = settings
+            .get("dimensions")?
+            .get("minecraft:overworld")?
+            .get("generator")?;
+        if crate::save::text(generator.get("type"))?.trim_start_matches("minecraft:") != "flat" {
+            return None;
+        }
+        Self::from_tag(generator.get("settings")?)
+    }
+    pub fn from_tag(tag: &Tag) -> Option<Self> {
+        let Some(Tag::List(list)) = tag.get("layers") else {
+            return None;
+        };
+        let layers: Vec<FlatLayer> = list
+            .iter()
+            .filter_map(|layer| {
+                Some(FlatLayer {
+                    block: crate::save::text(layer.get("block"))?,
+                    height: crate::save::number(layer.get("height"))?.clamp(0, Y_SIZE as i64)
+                        as i32,
+                })
+            })
+            .collect();
+        // `layers: []` is a valid void flat world; a list whose entries all
+        // fail to parse is not.
+        if layers.is_empty() && !list.is_empty() {
+            return None;
+        }
+        let flag = |key: &str, default: bool| {
+            crate::save::number(tag.get(key)).map_or(default, |value| value != 0)
+        };
+        let structure_overrides = match tag.get("structure_overrides") {
+            Some(Tag::String(text)) => vec![text.to_string_lossy()],
+            Some(Tag::List(list)) => list
+                .iter()
+                .filter_map(|value| crate::save::text(Some(value)))
+                .collect(),
+            _ => Vec::new(),
+        };
+        Some(Self {
+            biome: crate::save::text(tag.get("biome")).unwrap_or_else(|| "minecraft:plains".into()),
+            features: flag("features", false),
+            lakes: flag("lakes", false),
+            layers,
+            structure_overrides,
+        })
+    }
+    /// FlatLevelGeneratorSettings.CODEC, as world_gen_settings stores it.
+    pub fn to_tag(&self) -> Tag {
+        let string = |text: &str| Tag::String(text.into());
+        Tag::compound([
+            ("biome", string(&self.biome)),
+            ("features", Tag::Byte(i8::from(self.features))),
+            ("lakes", Tag::Byte(i8::from(self.lakes))),
+            (
+                "layers",
+                Tag::List(
+                    self.layers
+                        .iter()
+                        .map(|layer| {
+                            Tag::compound([
+                                ("block", string(&layer.block)),
+                                ("height", Tag::Int(layer.height)),
+                            ])
+                        })
+                        .collect(),
+                ),
+            ),
+            (
+                "structure_overrides",
+                Tag::List(
+                    self.structure_overrides
+                        .iter()
+                        .map(|id| string(id))
+                        .collect(),
+                ),
+            ),
+        ])
+    }
+    /// `CreateFlatWorldScreen.save`: the text the preset screen shows.
+    pub fn to_share(&self) -> String {
+        let layers = self
+            .layers
+            .iter()
+            .map(|layer| {
+                if layer.height == 1 {
+                    layer.block.clone()
+                } else {
+                    format!("{}*{}", layer.height, layer.block)
+                }
+            })
+            .collect::<Vec<_>>()
+            .join(",");
+        format!("{layers};{}", self.biome)
+    }
+    /// `PresetFlatWorldScreen.fromString`: `layers;biome`, keeping the
+    /// decorations the screen was opened with. `None` for a malformed list,
+    /// as vanilla falls back to the preset's own settings.
+    pub fn parse(
+        text: &str,
+        blocks: &BTreeSet<String>,
+        biomes: &BTreeSet<String>,
+        base: &Self,
+    ) -> Option<Self> {
+        let (layer_text, biome_text) = text.split_once(';').unwrap_or((text, ""));
+        let mut layers = Vec::new();
+        let mut total = 0;
+        for part in layer_text.split(',') {
+            let part = part.trim();
+            if part.is_empty() {
+                continue;
+            }
+            let (height, block) = match part.split_once('*') {
+                Some((height, block)) => (height.trim().parse::<i32>().ok()?, block.trim()),
+                None => (1, part),
+            };
+            let block = namespaced(block);
+            if !blocks.is_empty() && !blocks.contains(&block) {
+                return None;
+            }
+            let height = height.max(0).min(Y_SIZE - total);
+            if height == 0 {
+                continue;
+            }
+            total += height;
+            layers.push(FlatLayer { block, height });
+        }
+        if layers.is_empty() {
+            return None;
+        }
+        let mut biome = namespaced(biome_text.trim());
+        if biome == "minecraft:" || biome.is_empty() {
+            biome = "minecraft:plains".into();
+        }
+        if !biomes.is_empty() && !biomes.contains(&biome) {
+            biome = "minecraft:plains".into();
+        }
+        Some(Self {
+            biome,
+            layers,
+            ..base.clone()
+        })
+    }
+}
+/// `Identifier.parse`: bare names get the default namespace.
+fn namespaced(id: &str) -> String {
+    if id.is_empty() || id.contains(':') {
+        id.to_owned()
+    } else {
+        format!("minecraft:{id}")
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(super) enum Page {
+    Layers,
+    Presets,
+}
+
+#[derive(Clone, Debug)]
+pub struct State {
+    pub(super) page: Page,
+    pub(super) settings: FlatSettings,
+    /// The preset screen's share box (`createWorld.customize.presets.share`).
+    pub(super) share: String,
+    pub(super) share_focused: bool,
+    /// The selected layer, in the list's top-first order.
+    pub(super) selected: Option<usize>,
+    pub(super) scroll: ui::Scroll,
+    preset_selected: Option<usize>,
+    preset_scroll: ui::Scroll,
+    presets: Vec<Preset>,
+    blocks: BTreeSet<String>,
+    biomes: BTreeSet<String>,
+}
+#[derive(Clone, Debug)]
+struct Preset {
+    id: String,
+    display: String,
+    settings: FlatSettings,
+}
+impl State {
+    /// The layers the editor holds, for the control socket's state.
+    pub fn settings(&self) -> &FlatSettings {
+        &self.settings
+    }
+    pub(super) fn new(root: &Path, current: Option<FlatSettings>) -> Self {
+        let settings = current.unwrap_or_default();
+        let (presets, blocks, biomes) = load(root);
+        Self {
+            page: Page::Layers,
+            share: settings.to_share(),
+            settings,
+            share_focused: false,
+            selected: None,
+            scroll: ui::Scroll::default(),
+            preset_selected: None,
+            preset_scroll: ui::Scroll::default(),
+            presets,
+            blocks,
+            biomes,
+        }
+    }
+    pub(super) fn open_presets(&mut self) {
+        self.page = Page::Presets;
+        self.preset_selected = None;
+        self.preset_scroll = ui::Scroll::default();
+        self.share = self.settings.to_share();
+        self.share_focused = false;
+    }
+    pub(super) fn back_to_layers(&mut self) {
+        self.page = Page::Layers;
+        self.share_focused = false;
+    }
+    pub(super) fn remove_selected(&mut self) {
+        let Some(row) = self.selected else {
+            return;
+        };
+        let index = self.settings.layers.len().wrapping_sub(1 + row);
+        if index < self.settings.layers.len() {
+            self.settings.layers.remove(index);
+        }
+        self.selected = None;
+    }
+    /// PresetFlatWorldScreen's Select: parse the share text into the settings
+    /// the Create New World screen keeps.
+    pub(super) fn apply_share(&mut self) {
+        // PresetFlatWorldScreen keeps the selected preset's decorations while
+        // the share text supplies its layers and biome.
+        let base = self
+            .preset_selected
+            .and_then(|index| self.presets.get(index))
+            .map(|preset| preset.settings.clone())
+            .unwrap_or_else(|| self.settings.clone());
+        // A malformed list falls back to FlatLevelGeneratorSettings.getDefault.
+        let settings =
+            FlatSettings::parse(&self.share, &self.blocks, &self.biomes, &base).unwrap_or_default();
+        self.settings = settings;
+        self.share = self.settings.to_share();
+        self.page = Page::Layers;
+        self.share_focused = false;
+        self.selected = None;
+    }
+    fn select_preset(&mut self, index: usize) {
+        let Some(preset) = self.presets.get(index) else {
+            return;
+        };
+        self.preset_selected = Some(index);
+        self.share = preset.settings.to_share();
+        self.share_focused = false;
+    }
+    fn selecting(&self) -> Option<usize> {
+        self.preset_selected
+    }
+}
+
+/// `<root>/data/<namespace>/worldgen/flat_level_generator_preset/<path>.json`,
+/// in the order of the `visible` tag, plus the block and biome ids the share
+/// text is checked against.
+fn load(root: &Path) -> (Vec<Preset>, BTreeSet<String>, BTreeSet<String>) {
+    let mut presets = Vec::new();
+    let tag_path =
+        root.join("data/minecraft/tags/worldgen/flat_level_generator_preset/visible.json");
+    if let Ok(text) = std::fs::read_to_string(tag_path)
+        && let Ok(Value::Object(tag)) = serde_json::from_str(&text)
+        && let Some(Value::Array(ids)) = tag.get("values")
+    {
+        for id in ids.iter().filter_map(Value::as_str) {
+            let Some((namespace, path)) = id.split_once(':') else {
+                continue;
+            };
+            let path = root.join(format!(
+                "data/{namespace}/worldgen/flat_level_generator_preset/{path}.json"
+            ));
+            let Ok(text) = std::fs::read_to_string(path) else {
+                continue;
+            };
+            let Ok(value) = serde_json::from_str::<Value>(&text) else {
+                continue;
+            };
+            let Some(settings) = preset_settings(&value) else {
+                continue;
+            };
+            presets.push(Preset {
+                id: id.to_owned(),
+                display: value["display"]
+                    .as_str()
+                    .unwrap_or("minecraft:grass_block")
+                    .to_owned(),
+                settings,
+            });
+        }
+    }
+    let blocks = registry_ids(root, "minecraft:block");
+    let biomes = json_keys(&root.join("worldgen/biomes.json"));
+    (presets, blocks, biomes)
+}
+fn preset_settings(value: &Value) -> Option<FlatSettings> {
+    let settings = value.get("settings")?;
+    let layers = settings
+        .get("layers")?
+        .as_array()?
+        .iter()
+        .filter_map(|layer| {
+            Some(FlatLayer {
+                block: layer.get("block")?.as_str()?.to_owned(),
+                height: layer.get("height")?.as_i64()? as i32,
+            })
+        })
+        .collect::<Vec<_>>();
+    if layers.is_empty() {
+        return None;
+    }
+    let structure_overrides = match settings.get("structure_overrides") {
+        Some(Value::String(id)) => vec![id.clone()],
+        Some(Value::Array(ids)) => ids
+            .iter()
+            .filter_map(Value::as_str)
+            .map(str::to_owned)
+            .collect(),
+        _ => Vec::new(),
+    };
+    Some(FlatSettings {
+        biome: settings
+            .get("biome")
+            .and_then(Value::as_str)
+            .unwrap_or("minecraft:plains")
+            .to_owned(),
+        features: settings
+            .get("features")
+            .and_then(Value::as_bool)
+            .unwrap_or(false),
+        lakes: settings
+            .get("lakes")
+            .and_then(Value::as_bool)
+            .unwrap_or(false),
+        layers,
+        structure_overrides,
+    })
+}
+/// The ids of a registry in the prepared `registries.json`.
+fn registry_ids(root: &Path, registry: &str) -> BTreeSet<String> {
+    let Ok(text) = std::fs::read_to_string(root.join("registries.json")) else {
+        return BTreeSet::new();
+    };
+    let Ok(value) = serde_json::from_str::<Value>(&text) else {
+        return BTreeSet::new();
+    };
+    value
+        .get(registry)
+        .and_then(|registry| registry.get("entries"))
+        .and_then(Value::as_object)
+        .map(|entries| entries.keys().cloned().collect())
+        .unwrap_or_default()
+}
+fn json_keys(path: &Path) -> BTreeSet<String> {
+    let Ok(text) = std::fs::read_to_string(path) else {
+        return BTreeSet::new();
+    };
+    let Ok(value) = serde_json::from_str::<Value>(&text) else {
+        return BTreeSet::new();
+    };
+    value
+        .as_object()
+        .map(|entries| entries.keys().cloned().collect())
+        .unwrap_or_default()
+}
+
+/// CreateFlatWorldScreen's list and the preset screen's list.
+fn list_area(state: &State, size: (f32, f32)) -> (f32, f32, f32, f32) {
+    let (w, h) = (size.0.ceil(), size.1.ceil());
+    let (top, bottom) = match state.page {
+        Page::Layers => (43.0, h - 60.0),
+        Page::Presets => (80.0, h - 37.0),
+    };
+    let left = ((w - ROW_WIDTH) * 0.5).floor();
+    let rows = match state.page {
+        Page::Layers => HEADER + state.settings.layers.len() as f32 * LAYER_ROW + 4.0,
+        Page::Presets => state.presets.len() as f32 * PRESET_ROW + 4.0,
+    };
+    (top, bottom, left, rows)
+}
+
+pub(super) fn buttons(w: f32, h: f32, state: &State) -> Vec<Button> {
+    let b = |x: f32, y: f32, w: f32, key: &str, fallback: &str, enabled: bool, id: u8| Button {
+        x,
+        y,
+        w,
+        label: lang::get_or(key, fallback),
+        enabled,
+        id,
+        icon: None,
+    };
+    match state.page {
+        Page::Layers => {
+            let x = ((w - 308.0) * 0.5).trunc();
+            vec![
+                b(
+                    x,
+                    h - 52.0,
+                    150.0,
+                    "createWorld.customize.flat.removeLayer",
+                    "Remove Layer",
+                    state.selected.is_some(),
+                    70,
+                ),
+                b(
+                    x + 158.0,
+                    h - 52.0,
+                    150.0,
+                    "createWorld.customize.presets",
+                    "Presets",
+                    true,
+                    71,
+                ),
+                b(x, h - 28.0, 150.0, "gui.done", "Done", true, 72),
+                b(x + 158.0, h - 28.0, 150.0, "gui.cancel", "Cancel", true, 73),
+            ]
+        }
+        Page::Presets => vec![
+            b(
+                w / 2.0 - 155.0,
+                h - 28.0,
+                150.0,
+                "createWorld.customize.presets.select",
+                "Select",
+                state.selecting().is_some() || state.share.len() > 1,
+                74,
+            ),
+            b(
+                w / 2.0 + 5.0,
+                h - 28.0,
+                150.0,
+                "gui.cancel",
+                "Cancel",
+                true,
+                75,
+            ),
+        ],
+    }
+}
+
+/// The layer under the pointer (top-first), and whether the pointer is on the
+/// list at all.
+fn layer_row(state: &State, cursor: (f32, f32), size: (f32, f32)) -> Option<usize> {
+    let (top, bottom, _, _) = list_area(state, size);
+    if cursor.1 < top || cursor.1 >= bottom {
+        return None;
+    }
+    let y = cursor.1 - top - 2.0 + state.scroll.amount;
+    if y < HEADER {
+        return None;
+    }
+    let row = ((y - HEADER) / LAYER_ROW).floor() as usize;
+    (row < state.settings.layers.len()).then_some(row)
+}
+fn preset_row(state: &State, cursor: (f32, f32), size: (f32, f32)) -> Option<usize> {
+    let (top, bottom, _, _) = list_area(state, size);
+    if cursor.1 < top || cursor.1 >= bottom {
+        return None;
+    }
+    let row = ((cursor.1 - top - 2.0 + state.preset_scroll.amount) / PRESET_ROW).floor() as usize;
+    (row < state.presets.len()).then_some(row)
+}
+
+/// A press on the list, the share box or its scrollbar.
+pub(super) fn click(state: &mut State, cursor: (f32, f32), size: (f32, f32)) {
+    let (top, bottom, left, content) = list_area(state, size);
+    let bar = left + ROW_WIDTH + 6.0;
+    match state.page {
+        Page::Layers => {
+            if state.scroll.press(cursor, bar, top, bottom, content) {
+                return;
+            }
+            state.selected = layer_row(state, cursor, size);
+        }
+        Page::Presets => {
+            let field = share_field(size);
+            state.share_focused = ui::hovered(cursor, field[0], field[1], field[2], field[3]);
+            if state.preset_scroll.press(cursor, bar, top, bottom, content) {
+                return;
+            }
+            if let Some(row) = preset_row(state, cursor, size) {
+                state.select_preset(row);
+            }
+        }
+    }
+}
+fn share_field(size: (f32, f32)) -> [f32; 4] {
+    [50.0, 40.0, (size.0.ceil() - 100.0).max(1.0), 20.0]
+}
+
+pub(super) fn wheel(state: &mut State, delta: f32, cursor: (f32, f32), size: (f32, f32)) {
+    let (top, bottom, _, content) = list_area(state, size);
+    if cursor.1 < top || cursor.1 >= bottom {
+        return;
+    }
+    match state.page {
+        Page::Layers => state.scroll.wheel(delta, LAYER_ROW, top, bottom, content),
+        Page::Presets => state
+            .preset_scroll
+            .wheel(delta, PRESET_ROW, top, bottom, content),
+    }
+}
+pub(super) fn drag(state: &mut State, cursor: (f32, f32), size: (f32, f32)) {
+    let (top, bottom, _, content) = list_area(state, size);
+    match state.page {
+        Page::Layers => state.scroll.drag(cursor.1, top, bottom, content),
+        Page::Presets => state.preset_scroll.drag(cursor.1, top, bottom, content),
+    }
+}
+pub(super) fn release(state: &mut State) {
+    state.scroll.release();
+    state.preset_scroll.release();
+}
+
+pub(super) fn draw(
+    title: &Title,
+    atlas: &HudAtlas,
+    batch: &mut HudBatch,
+    cursor: (f32, f32),
+    state: &State,
+) {
+    let (w, h) = (batch.width.ceil(), batch.height.ceil());
+    ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false);
+    match state.page {
+        Page::Layers => draw_layers(title, atlas, batch, cursor, state, (w, h)),
+        Page::Presets => draw_presets(title, atlas, batch, cursor, state, (w, h)),
+    }
+}
+
+fn draw_layers(
+    _title: &Title,
+    atlas: &HudAtlas,
+    batch: &mut HudBatch,
+    cursor: (f32, f32),
+    state: &State,
+    (w, h): (f32, f32),
+) {
+    super::centered(
+        atlas,
+        batch,
+        &lang::get_or(
+            "createWorld.customize.flat.title",
+            "Superflat Customization",
+        ),
+        8.0,
+        u32::MAX,
+    );
+    let (top, bottom, left, content) = list_area(state, (w, h));
+    ui::list_background(batch, atlas, top, bottom, false);
+    crate::ui::separators(batch, atlas, top, bottom, false);
+    let first = batch.vertices.len();
+    let right = left + ROW_WIDTH;
+    batch.text_styled(
+        atlas,
+        &Text::translate("createWorld.customize.flat.tile", &[]).underlined(),
+        left + 2.0,
+        top + 3.0,
+        u32::MAX,
+        true,
+    );
+    let height_header = Text::translate("createWorld.customize.flat.height", &[]).underlined();
+    let hw = HudBatch::text_width(atlas, &height_header.plain());
+    batch.text_styled(
+        atlas,
+        &height_header,
+        right - hw - 2.0,
+        top + 3.0,
+        u32::MAX,
+        true,
+    );
+    let offset = state.scroll.amount.trunc();
+    let selected = state.selected;
+    for (row, layer) in state.settings.layers.iter().rev().enumerate() {
+        let y = top + 2.0 + HEADER + row as f32 * LAYER_ROW - offset;
+        let target = [left - 2.0, y - 1.0, ROW_WIDTH + 4.0, LAYER_ROW];
+        let hovered = ui::hovered(cursor, target[0], target[1], target[2], target[3]);
+        if selected == Some(row) {
+            batch.fill(
+                atlas,
+                target[0],
+                target[1],
+                target[2],
+                target[3],
+                rgba(255, 255, 255, 70),
+            );
+        } else if hovered {
+            batch.fill(
+                atlas,
+                target[0],
+                target[1],
+                target[2],
+                target[3],
+                rgba(255, 255, 255, 25),
+            );
+        }
+        slot(
+            atlas,
+            batch,
+            layer_icon(atlas, &layer.block),
+            left + 2.0,
+            y + 1.0,
+        );
+        batch.text(
+            atlas,
+            &item_name(&layer.block),
+            left + 2.0 + 18.0 + 5.0,
+            y + 5.0,
+            u32::MAX,
+            true,
+        );
+        let (key, fallback) = if row == 0 {
+            ("createWorld.customize.flat.layer.top", "Top - %s")
+        } else if row + 1 == state.settings.layers.len() {
+            ("createWorld.customize.flat.layer.bottom", "Bottom - %s")
+        } else {
+            ("createWorld.customize.flat.layer", "%s")
+        };
+        let label = format_translation(
+            &lang::get_or(key, fallback),
+            &[Text::literal(layer.height.to_string())],
+        )
+        .plain();
+        let text_width = HudBatch::text_width(atlas, &label);
+        batch.text(
+            atlas,
+            &label,
+            right - text_width - 2.0,
+            y + 5.0,
+            u32::MAX,
+            true,
+        );
+    }
+    batch.clip_since(first, 0.0, top, w, bottom);
+    ui::scrollbar(
+        batch,
+        atlas,
+        left + ROW_WIDTH + 6.0,
+        top,
+        bottom,
+        content,
+        state.scroll.amount,
+    );
+}
+
+fn draw_presets(
+    title: &Title,
+    atlas: &HudAtlas,
+    batch: &mut HudBatch,
+    cursor: (f32, f32),
+    state: &State,
+    (w, h): (f32, f32),
+) {
+    super::centered(
+        atlas,
+        batch,
+        &lang::get_or("createWorld.customize.presets.title", "Select a Preset"),
+        8.0,
+        u32::MAX,
+    );
+    batch.text(
+        atlas,
+        &lang::get_or(
+            "createWorld.customize.presets.share",
+            "Want to share your preset with someone? Use the box below!",
+        ),
+        51.0,
+        30.0,
+        rgba(160, 160, 160, 255),
+        true,
+    );
+    // The share box: EditBox at 50,40, width - 100 by 20.
+    let field = share_field((w, h));
+    title.caret.borrow_mut().draw(
+        batch,
+        atlas,
+        (super::FLAT_SHARE, &state.share, 1230),
+        field,
+        state.share_focused,
+        title.started,
+    );
+    batch.text(
+        atlas,
+        &lang::get_or(
+            "createWorld.customize.presets.list",
+            "Alternatively, here are some we made earlier!",
+        ),
+        51.0,
+        68.0,
+        rgba(160, 160, 160, 255),
+        true,
+    );
+    let (top, bottom, left, content) = list_area(state, (w, h));
+    ui::list_background(batch, atlas, top, bottom, false);
+    crate::ui::separators(batch, atlas, top, bottom, false);
+    let first = batch.vertices.len();
+    let offset = state.preset_scroll.amount.trunc();
+    for (row, preset) in state.presets.iter().enumerate() {
+        let y = top + 2.0 + row as f32 * PRESET_ROW - offset;
+        let target = [left - 2.0, y - 1.0, ROW_WIDTH + 4.0, PRESET_ROW];
+        let hovered = ui::hovered(cursor, target[0], target[1], target[2], target[3]);
+        if state.preset_selected == Some(row) {
+            batch.fill(
+                atlas,
+                target[0],
+                target[1],
+                target[2],
+                target[3],
+                rgba(255, 255, 255, 70),
+            );
+        } else if hovered {
+            batch.fill(
+                atlas,
+                target[0],
+                target[1],
+                target[2],
+                target[3],
+                rgba(255, 255, 255, 25),
+            );
+        }
+        slot(
+            atlas,
+            batch,
+            layer_icon(atlas, &preset.display),
+            left + 2.0,
+            y + 2.0,
+        );
+        batch.text(
+            atlas,
+            &preset_name(&preset.id),
+            left + 2.0 + 18.0 + 5.0,
+            y + 7.0,
+            u32::MAX,
+            true,
+        );
+    }
+    batch.clip_since(first, 0.0, top, w, bottom);
+    ui::scrollbar(
+        batch,
+        atlas,
+        left + ROW_WIDTH + 6.0,
+        top,
+        bottom,
+        content,
+        state.preset_scroll.amount,
+    );
+}
+
+/// The 18x18 slot behind a layer's item icon (`container/slot`).
+fn slot(atlas: &HudAtlas, batch: &mut HudBatch, icon: Option<String>, x: f32, y: f32) {
+    if let Some(rect) = atlas.sprites.get("gui/sprites/container/slot").copied() {
+        batch.rect_uv(x, y, 18.0, 18.0, rect, u32::MAX);
+    } else {
+        batch.fill(atlas, x, y, 18.0, 18.0, rgba(139, 139, 139, 255));
+        batch.fill(atlas, x + 1.0, y + 1.0, 16.0, 16.0, rgba(55, 55, 55, 255));
+    }
+    if let Some(icon) = icon {
+        batch.sprite_scaled(atlas, &icon, x + 1.0, y + 1.0, 16.0, 16.0, u32::MAX);
+    }
+}
+fn layer_icon(atlas: &HudAtlas, id: &str) -> Option<String> {
+    let name = id.strip_prefix("minecraft:").unwrap_or(id);
+    let candidates: Vec<String> = if name == "water" {
+        vec!["item/water_bucket".into()]
+    } else if name == "lava" {
+        vec!["item/lava_bucket".into()]
+    } else {
+        vec![
+            format!("item/{name}"),
+            format!("block/{name}"),
+            format!("block/{name}_side"),
+            format!("block/{name}_top"),
+        ]
+    };
+    candidates
+        .into_iter()
+        .find(|sprite| atlas.sprites.contains_key(sprite))
+}
+fn item_name(id: &str) -> String {
+    let name = id.strip_prefix("minecraft:").unwrap_or(id);
+    if name == "water" {
+        return lang::get_or("item.minecraft.water_bucket", "Water Bucket");
+    }
+    if name == "lava" {
+        return lang::get_or("item.minecraft.lava_bucket", "Lava Bucket");
+    }
+    for key in [
+        format!("block.minecraft.{name}"),
+        format!("item.minecraft.{name}"),
+    ] {
+        if lang::has(&key) {
+            return lang::get(&key);
+        }
+    }
+    pretty(name)
+}
+fn preset_name(id: &str) -> String {
+    let key = format!("flat_world_preset.{}", id.replace(':', "."));
+    lang::get_or(&key, &pretty(id.strip_prefix("minecraft:").unwrap_or(id)))
+}
+fn pretty(name: &str) -> String {
+    name.split('_')
+        .filter(|word| !word.is_empty())
+        .map(|word| {
+            let mut chars = word.chars();
+            match chars.next() {
+                Some(first) => first.to_uppercase().chain(chars).collect::<String>(),
+                None => String::new(),
+            }
+        })
+        .collect::<Vec<_>>()
+        .join(" ")
+}
diff --git a/crates/horizon-client/src/title/tests.rs b/crates/horizon-client/src/title/tests.rs
index fcaf68225..04fefe366 100644
--- a/crates/horizon-client/src/title/tests.rs
+++ b/crates/horizon-client/src/title/tests.rs
@@ -770,9 +770,12 @@ fn create_world_tabs_follow_vanilla_and_their_choices_reach_the_action() {
             bonus_chest: true
         }
     );
-    // The More tab's screens don't exist yet.
+    // The More tab's Experiments and Data Packs screens don't exist yet.
     f.title.click(54.0 + 248.0 + 10.0, 10.0, size);
-    assert!(labels(&f)[..3].iter().all(|b| !b.3));
+    assert_eq!(
+        labels(&f)[..3].iter().map(|b| b.3).collect::<Vec<_>>(),
+        [true, false, false]
+    );
 }
 
 #[test]
diff --git a/crates/horizon-client/src/vanillagen.rs b/crates/horizon-client/src/vanillagen.rs
index 923818a08..f51eb8208 100644
--- a/crates/horizon-client/src/vanillagen.rs
+++ b/crates/horizon-client/src/vanillagen.rs
@@ -24,7 +24,9 @@ use horizon_world::{
 };
 use std::{path::Path, sync::Arc};
 mod lod;
+mod structure_mobs;
 use lod::VanillaLodSampler;
+use structure_mobs::StructureMobFinalizer;
 
 pub struct VanillaTerrain {
     generator: OverworldGenerator,
@@ -32,6 +34,7 @@ pub struct VanillaTerrain {
     biome_map: Vec<u16>,
     /// Loot tables for generated containers.
     loot: Option<Arc<horizon_world::loot::LootData>>,
+    structure_mobs: Arc<StructureMobFinalizer>,
     /// A worker for structure queries from the game thread.
     query: std::sync::Mutex<Option<GeneratorWorker>>,
     /// Block state id -> block index, the game's block tick type: worldgen
@@ -39,6 +42,8 @@ pub struct VanillaTerrain {
     tick_blocks: Vec<u32>,
     /// Block index -> default state id: `tick_blocks` the other way.
     tick_states: Vec<u32>,
+    /// Block state id -> the block entity type of its block, if it has one.
+    block_entity_types: Vec<Option<&'static str>>,
     seed: i64,
     dimension: String,
     /// When the last proto chunk was generated, in milliseconds since
@@ -51,6 +56,51 @@ enum VanillaProto {
     Ready(Box<ProtoChunk>),
     Failed(i32, i32),
 }
+/// WorldGenRegion.setBlock gives every block with a block entity a new
+/// one: the blocks nothing placed data for (a sculk patch's sensors) get
+/// vanilla's defaults.
+fn add_default_block_entities(kinds: &[Option<&str>], out: &mut Chunk, raw: &mut Vec<Tag>) {
+    let kind = |v: u32| kinds.get(v as usize).copied().flatten();
+    let mut states = [0u32; 4096];
+    for (si, section) in out.sections.iter().enumerate() {
+        if !section.blocks.maybe_has(|v| kind(v).is_some()) {
+            continue;
+        }
+        section.unpack(&mut states);
+        for (i, &v) in states.iter().enumerate() {
+            let Some(id) = kind(v) else {
+                continue;
+            };
+            let i = i as i32;
+            let pos = [
+                out.x * 16 + (i & 15),
+                MIN_Y + si as i32 * 16 + (i >> 8),
+                out.z * 16 + ((i >> 4) & 15),
+            ];
+            let at = |t: &Tag| {
+                ["x", "y", "z"]
+                    .iter()
+                    .zip(pos)
+                    .all(|(k, p)| t.get(k) == Some(&Tag::Int(p)))
+            };
+            if raw.iter().any(at) || out.block_entities.iter().any(|(p, _)| *p == pos.into()) {
+                continue;
+            }
+            let tag = Tag::compound([
+                ("id", Tag::String(id.into())),
+                ("x", Tag::Int(pos[0])),
+                ("y", Tag::Int(pos[1])),
+                ("z", Tag::Int(pos[2])),
+            ]);
+            let tag = crate::block_entity_nbt::canonical(&tag).unwrap_or(tag);
+            match crate::save::decode_block_entity(&tag) {
+                Some(modelled) => out.block_entities.push(modelled),
+                None => raw.push(tag),
+            }
+        }
+    }
+}
+
 impl VanillaTerrain {
     fn client_surface(&self, surface: SurfaceSample) -> crate::lod::Surface {
         crate::lod::Surface {
@@ -119,6 +169,7 @@ impl VanillaTerrain {
         }
         let mut tick_blocks = Vec::with_capacity(registry.len());
         let mut tick_states = Vec::new();
+        let mut block_entity_types = Vec::with_capacity(registry.len());
         let mut last: Option<&str> = None;
         let mut index = 0u32;
         for id in 0..registry.len() {
@@ -133,20 +184,31 @@ impl VanillaTerrain {
             }
             last = Some(name);
             tick_blocks.push(index);
+            block_entity_types.push(crate::lan::chunks::block_entity_type(name));
         }
         Ok(Self {
             generator,
             biome_map,
             loot,
+            structure_mobs: Arc::new(StructureMobFinalizer::new(
+                dir.parent().unwrap_or(dir).to_owned(),
+                dimension,
+            )),
             query: std::sync::Mutex::new(None),
             tick_blocks,
             tick_states,
+            block_entity_types,
             seed,
             dimension: dimension.to_owned(),
             last_proto: std::sync::atomic::AtomicU64::new(0),
             created: std::time::Instant::now(),
         })
     }
+    /// The difficulty (0 peaceful to 3 hard) and overworld clock structure
+    /// mobs are finalized with.
+    pub fn set_spawn_conditions(&self, difficulty: u8, day_time: i64) {
+        self.structure_mobs.set_conditions(difficulty, day_time);
+    }
     /// A proto chunk's blocks, biomes, scheduled ticks and post-processing
     /// marks as a column.
     fn column(&self, chunk: &ProtoChunk) -> Chunk {
@@ -333,15 +395,23 @@ impl VanillaTerrain {
         u64::try_from(self.created.elapsed().as_millis()).unwrap_or(u64::MAX)
     }
 }
+static SHARED_DATA: std::sync::Mutex<Vec<(std::path::PathBuf, Arc<GeneratorData>)>> =
+    std::sync::Mutex::new(Vec::new());
+/// Let go of the bundles `shared_data` loaded: for a preload no world used
+/// (game/world_loading.rs). A generator that holds one keeps it.
+pub fn forget_shared_data() {
+    SHARED_DATA
+        .lock()
+        .unwrap_or_else(|e| e.into_inner())
+        .clear();
+}
 /// The worldgen bundle at `dir`, loaded once and shared by every generator
 /// and by live feature placement (sapling growth, bone meal).
 pub fn shared_data(
     dir: &Path,
     registry: &'static BlockRegistry,
 ) -> crate::Result<Arc<GeneratorData>> {
-    static CACHE: std::sync::Mutex<Vec<(std::path::PathBuf, Arc<GeneratorData>)>> =
-        std::sync::Mutex::new(Vec::new());
-    let mut cache = CACHE.lock().unwrap_or_else(|e| e.into_inner());
+    let mut cache = SHARED_DATA.lock().unwrap_or_else(|e| e.into_inner());
     if let Some((_, data)) = cache.iter().find(|(path, _)| path == dir) {
         return Ok(data.clone());
     }
@@ -354,7 +424,9 @@ pub fn shared_data(
 impl ChunkGenerator for VanillaTerrain {
     type Worker = GeneratorWorker;
     fn worker(&self) -> GeneratorWorker {
-        self.generator.worker()
+        let mut worker = self.generator.worker();
+        worker.set_structure_mobs(self.structure_mobs.clone());
+        worker
     }
     fn lod_sampler(self: Arc<Self>) -> Box<dyn LodSampler> {
         Box::new(VanillaLodSampler::new(self))
@@ -433,6 +505,12 @@ impl ChunkGenerator for VanillaTerrain {
     fn is_decorated(&self, proto: &Proto) -> bool {
         matches!(proto.downcast_ref::<VanillaProto>(), Some(VanillaProto::Ready(c)) if c.is_decorated())
     }
+    fn light_view(&self, proto: &Proto) -> Option<Chunk> {
+        match proto.downcast_ref::<VanillaProto>() {
+            Some(VanillaProto::Ready(chunk)) => Some(self.column(chunk)),
+            _ => None,
+        }
+    }
     fn saved_proto(&self, proto: &Proto) -> Option<SavedProto> {
         let Some(VanillaProto::Ready(chunk)) = proto.downcast_ref::<VanillaProto>() else {
             return None;
@@ -553,7 +631,7 @@ impl ChunkGenerator for VanillaTerrain {
         // The block entities Horizon does not model (decorated pots with their
         // sherds and loot table, brushable blocks) stay as placed, like a
         // loaded chunk's.
-        let unmodelled: Vec<Tag> = chunk
+        let mut unmodelled: Vec<Tag> = chunk
             .block_entities
             .iter()
             .filter(|(pos, _)| {
@@ -573,6 +651,7 @@ impl ChunkGenerator for VanillaTerrain {
                 Some(Tag::Compound(nbt))
             })
             .collect();
+        add_default_block_entities(&self.block_entity_types, &mut out, &mut unmodelled);
         if !unmodelled.is_empty() || !rolled_loot.is_empty() {
             let mut extras = out
                 .saved
@@ -596,3 +675,35 @@ impl ChunkGenerator for VanillaTerrain {
         out
     }
 }
+
+#[cfg(test)]
+mod default_block_entity_tests {
+    use super::*;
+
+    #[test]
+    fn generated_blocks_get_their_block_entities() {
+        let mut out = Chunk::empty(-2, 3);
+        out.set(4, -40, 9, 7);
+        out.set(5, -40, 9, 6);
+        let mut kinds = vec![None; 8];
+        kinds[6] = Some("minecraft:potent_sulfur");
+        kinds[7] = Some("minecraft:sculk_sensor");
+        let mut raw = vec![];
+        add_default_block_entities(&kinds, &mut out, &mut raw);
+        assert!(matches!(
+            out.block_entities[..],
+            [((-28, -40, 57), crate::containers::BlockEntity::Sculk(_))]
+        ));
+        assert_eq!(raw.len(), 1);
+        assert_eq!(
+            raw[0].get("id"),
+            Some(&Tag::String("minecraft:potent_sulfur".into()))
+        );
+        add_default_block_entities(&kinds, &mut out, &mut raw);
+        assert_eq!(
+            (out.block_entities.len(), raw.len()),
+            (1, 1),
+            "a placed block entity is kept, not doubled"
+        );
+    }
+}
diff --git a/crates/horizon-client/src/vanillagen/structure_mobs.rs b/crates/horizon-client/src/vanillagen/structure_mobs.rs
new file mode 100644
index 000000000..dec5aa92b
--- /dev/null
+++ b/crates/horizon-client/src/vanillagen/structure_mobs.rs
@@ -0,0 +1,446 @@
+//! `Mob.finalizeSpawn(level, level.getCurrentDifficultyAt(pos), STRUCTURE, null)`
+//! of the mobs structures place (StructureTemplate.placeEntities with
+//! finalizeEntities, ocean ruin drowned, mansion illagers, witch huts,
+//! monuments), run as decoration places them, with the WorldGenRegion's random.
+use crate::{
+    enchant::Enchantments,
+    entity_nbt,
+    items::Items,
+    mobs::{
+        Mob, MobType, MobTypes,
+        finalize::{self, Ctx, FinalizeLevel, Reason, SpawnData, SpawnRegistries},
+        spawning::{LocalDifficulty, MOON_BRIGHTNESS},
+    },
+};
+use chrono::Datelike;
+use horizon_core::{
+    geometry::{Aabb, Vec3},
+    random::{LegacyRandom, RandomSource, XoroshiroRandom},
+};
+use horizon_world::{
+    nbt::{Compound, Tag},
+    worldgen::{generator::StructureMobs, structure::legacy::PieceRandom},
+};
+use std::{
+    collections::{HashMap, HashSet},
+    path::PathBuf,
+    sync::{
+        Arc, OnceLock,
+        atomic::{AtomicI64, AtomicU8, Ordering},
+    },
+};
+
+struct Data {
+    types: HashMap<String, Arc<MobType>>,
+    biome_tags: HashMap<String, HashSet<String>>,
+    registries: SpawnRegistries,
+    enchantments: Enchantments,
+    items: Items,
+    camel_husk: (f32, f32),
+}
+fn load(root: &std::path::Path) -> Option<Data> {
+    let types = MobTypes::load(root).ok()?.types;
+    let camel = types.get("minecraft:camel_husk")?;
+    let camel_husk = (camel.width as f32, camel.height as f32);
+    Some(Data {
+        types: types.into_iter().map(|(k, t)| (k, Arc::new(t))).collect(),
+        biome_tags: crate::items::load_tags(root, "worldgen/biome").unwrap_or_default(),
+        registries: SpawnRegistries::load(root),
+        enchantments: Enchantments::load(root),
+        items: Items::tags_only(root).ok()?,
+        camel_husk,
+    })
+}
+
+pub struct StructureMobFinalizer {
+    root: PathBuf,
+    dimension: String,
+    data: OnceLock<Option<Data>>,
+    /// The level's difficulty (0 peaceful to 3 hard) and overworld clock.
+    difficulty: AtomicU8,
+    day_time: AtomicI64,
+}
+impl StructureMobFinalizer {
+    pub fn new(root: PathBuf, dimension: &str) -> Self {
+        Self {
+            root,
+            dimension: dimension.to_owned(),
+            data: OnceLock::new(),
+            difficulty: AtomicU8::new(2),
+            day_time: AtomicI64::new(0),
+        }
+    }
+    pub fn set_conditions(&self, difficulty: u8, day_time: i64) {
+        self.difficulty.store(difficulty, Ordering::Relaxed);
+        self.day_time.store(day_time, Ordering::Relaxed);
+    }
+}
+
+struct Level<'a> {
+    data: &'a Data,
+    biome: &'a str,
+    structures: &'a [String],
+    difficulty: u8,
+    day_time: i64,
+    next_id: u32,
+}
+impl FinalizeLevel for Level<'_> {
+    fn biome(&self, _: [i32; 3]) -> String {
+        self.biome.to_owned()
+    }
+    fn biome_tag(&self, tag: &str, _: [i32; 3]) -> bool {
+        self.data
+            .biome_tags
+            .get(tag)
+            .is_some_and(|b| b.contains(self.biome))
+    }
+    fn structures_with_piece_at(&self, _: [i32; 3]) -> Vec<String> {
+        self.structures.to_vec()
+    }
+    fn moon_phase(&self, _: [i32; 3]) -> usize {
+        self.day_time.div_euclid(24000).rem_euclid(8) as usize
+    }
+    fn spawning_monsters(&self) -> bool {
+        self.difficulty != 0
+    }
+    // No block collision: only a husk's camel asks, and no structure places husks.
+    fn no_collision(&self, _: Aabb) -> bool {
+        true
+    }
+    // WorldGenRegion holds no entities.
+    fn free_chicken(&self, _: Aabb) -> Option<u32> {
+        None
+    }
+    fn ride_chicken(&mut self, _: u32, _: u32) {}
+    fn game_time(&self) -> i64 {
+        self.day_time
+    }
+    fn halloween(&self) -> bool {
+        let today = chrono::Local::now();
+        (today.month(), today.day()) == (10, 31)
+    }
+    fn create(&mut self, kind: &str, _: Reason) -> Option<Mob> {
+        if self.difficulty == 0 && !finalize::allowed_in_peaceful(kind) {
+            return None;
+        }
+        let t = self.data.types.get(kind)?.clone();
+        self.next_id += 1;
+        Some(Mob::new(self.next_id, t, Vec3::ZERO, 0.0))
+    }
+}
+
+fn run<R: RandomSource>(
+    level: &mut Level<'_>,
+    random: &mut R,
+    difficulty: LocalDifficulty,
+    data: &SpawnData<'_>,
+    m: &mut Mob,
+) -> Vec<Mob> {
+    let mut cx = Ctx {
+        level,
+        random,
+        difficulty,
+        data,
+        created: Vec::new(),
+    };
+    cx.finalize(m, Reason::Structure, None);
+    cx.created
+}
+
+/// The saved compound of mob `i` with the mobs riding it under `Passengers`.
+fn tree(mobs: &[(Mob, Option<Tag>)], i: usize, dimension: &str) -> Compound {
+    let (m, raw) = &mobs[i];
+    let Tag::Compound(mut c) = entity_nbt::mob_to_nbt(m, [0; 4], raw.as_ref()) else {
+        return Compound::new();
+    };
+    c.remove(&"UUID".into());
+    entity_nbt::put_brain(&mut c, m, dimension);
+    let riders: Vec<Tag> = (0..mobs.len())
+        .filter(|&j| mobs[j].0.extra.mount == Some(m.id))
+        .map(|j| Tag::Compound(tree(mobs, j, dimension)))
+        .collect();
+    if !riders.is_empty() {
+        c.insert("Passengers".into(), Tag::List(riders));
+    }
+    c
+}
+
+impl StructureMobs for StructureMobFinalizer {
+    fn finalize(
+        &self,
+        nbt: &mut Compound,
+        biome: &str,
+        structures: &[String],
+        random: &mut dyn PieceRandom,
+    ) -> bool {
+        let Some(data) = self.data.get_or_init(|| {
+            let data = load(&self.root);
+            if data.is_none() {
+                log::error!("Horizon: no mob data, structure mobs are finalized when loaded");
+            }
+            data
+        }) else {
+            return false;
+        };
+        let mut raw = Tag::Compound(nbt.clone());
+        if let Tag::Compound(c) = &mut raw {
+            c.remove(&"horizon:finalize".into());
+        }
+        let Some(mut m) = entity_nbt::mob_from_nbt(&raw, &data.types, 1) else {
+            // Not a mob: vanilla finalizes only Mob instances.
+            return true;
+        };
+        let base = self.difficulty.load(Ordering::Relaxed);
+        let day_time = self.day_time.load(Ordering::Relaxed);
+        let mut level = Level {
+            data,
+            biome,
+            structures,
+            difficulty: base,
+            day_time,
+            next_id: 1,
+        };
+        let moon = MOON_BRIGHTNESS[level.moon_phase([0; 3])];
+        // WorldGenRegion.getCurrentDifficultyAt: no inhabited time.
+        let difficulty = LocalDifficulty::new(base, day_time, 0, moon);
+        let spawn = SpawnData {
+            registries: &data.registries,
+            enchantments: &data.enchantments,
+            items: &data.items,
+            camel_husk_size: data.camel_husk,
+        };
+        let any = random.as_any();
+        let created = if let Some(r) = any.downcast_mut::<LegacyRandom>() {
+            run(&mut level, r, difficulty, &spawn, &mut m)
+        } else if let Some(r) = any.downcast_mut::<XoroshiroRandom>() {
+            run(&mut level, r, difficulty, &spawn, &mut m)
+        } else {
+            log::error!("Horizon: unknown region random, structure mobs are finalized when loaded");
+            return false;
+        };
+        let mut mobs = vec![(m, Some(raw))];
+        mobs.extend(created.into_iter().map(|c| (c, None)));
+        let root = mobs
+            .iter()
+            .position(|(m, _)| m.extra.mount.is_none())
+            .unwrap_or(0);
+        *nbt = tree(&mobs, root, &self.dimension);
+        true
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The bastion's crossbow piglin keeps its crossbow (STRUCTURE skips
+    /// createSpawnWeapon) and saves what Piglin.addAdditionalSaveData writes.
+    #[test]
+    fn bastion_crossbow_piglin_finalizes_as_structure() {
+        let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES").map(PathBuf::from) else {
+            return;
+        };
+        let file = root.join("worldgen/structure/minecraft/bastion/mobs/crossbow_piglin.nbt");
+        let mut bytes = Vec::new();
+        std::io::Read::read_to_end(
+            &mut flate2::read::GzDecoder::new(std::fs::File::open(file).unwrap()),
+            &mut bytes,
+        )
+        .unwrap();
+        let limits = horizon_world::nbt::Limits::templates();
+        let template = horizon_world::nbt::read_named(&bytes, limits)
+            .unwrap()
+            .0
+            .tag;
+        let Some(Tag::List(entities)) = template.get("entities") else {
+            panic!("no entities");
+        };
+        let Some(Tag::Compound(mut nbt)) = entities[0].get("nbt").cloned() else {
+            panic!("no nbt");
+        };
+        nbt.remove(&"UUID".into());
+        let hook = StructureMobFinalizer::new(root, "minecraft:the_nether");
+        let mut random = LegacyRandom::new(12345);
+        hook.finalize(&mut nbt, "minecraft:nether_wastes", &[], &mut random);
+        let keys: Vec<String> = {
+            let mut k: Vec<String> = nbt.keys().map(|k| k.to_string_lossy()).collect();
+            k.sort();
+            k
+        };
+        assert_eq!(
+            keys,
+            [
+                "AbsorptionAmount",
+                "Air",
+                "Brain",
+                "CanPickUpLoot",
+                "CannotHunt",
+                "DeathTime",
+                "FallFlying",
+                "Fire",
+                "Health",
+                "HurtTime",
+                "Inventory",
+                "Invulnerable",
+                "IsBaby",
+                "IsImmuneToZombification",
+                "LeftHanded",
+                "Motion",
+                "OnGround",
+                "PersistenceRequired",
+                "PortalCooldown",
+                "Pos",
+                "Rotation",
+                "TimeInOverworld",
+                "attributes",
+                "current_impulse_context_reset_grace_time",
+                "equipment",
+                "fall_distance",
+                "id",
+            ]
+        );
+        let tag = Tag::Compound(nbt);
+        let held = tag.get("equipment").and_then(|e| e.get("mainhand"));
+        assert!(
+            matches!(held.and_then(|h| h.get("id")), Some(Tag::String(s)) if s.to_string_lossy() == "minecraft:crossbow")
+        );
+        let hunted = tag
+            .get("Brain")
+            .and_then(|b| b.get("memories"))
+            .and_then(|m| m.get("minecraft:hunted_recently"));
+        assert!(matches!(
+            hunted.and_then(|h| h.get("ttl")),
+            Some(Tag::Long(600..=2400))
+        ));
+        let Some(Tag::List(attributes)) = tag.get("attributes") else {
+            panic!("no attributes");
+        };
+        assert!(attributes.iter().any(|a| {
+            matches!(a.get("id"), Some(Tag::String(s)) if s.to_string_lossy() == "minecraft:follow_range")
+                && matches!(a.get("modifiers"), Some(Tag::List(m)) if m.len() == 1)
+        }));
+    }
+
+    fn id(t: Option<&Tag>) -> String {
+        match t.and_then(|t| t.get("id")) {
+            Some(Tag::String(s)) => s.to_string_lossy().trim_start_matches("minecraft:").into(),
+            _ => "-".into(),
+        }
+    }
+    /// What a vanilla world saves of a structure mob that finalizeSpawn decides.
+    fn describe(mob: &Tag) -> String {
+        let eq = mob.get("equipment");
+        let gear: Vec<String> = ["mainhand", "head", "chest", "legs", "feet"]
+            .iter()
+            .map(|slot| id(eq.and_then(|e| e.get(slot))))
+            .collect();
+        let ttl = match mob
+            .get("Brain")
+            .and_then(|b| b.get("memories"))
+            .and_then(|m| m.get("minecraft:hunted_recently"))
+            .and_then(|h| h.get("ttl"))
+        {
+            Some(Tag::Long(t)) => t.to_string(),
+            _ => "-".into(),
+        };
+        let bonus = crate::entity_nbt::spawn_bonus(mob).unwrap_or(f64::NAN);
+        let flag = |k: &str| matches!(mob.get(k), Some(Tag::Byte(1)));
+        let riders = match mob.get("Passengers") {
+            Some(Tag::List(p)) => format!(
+                " [{}]",
+                p.iter().map(describe).collect::<Vec<_>>().join("; ")
+            ),
+            _ => String::new(),
+        };
+        format!(
+            "{} {} ttl={ttl} bonus={bonus:.6} left={} baby={}{riders}",
+            id(Some(mob)),
+            gear.join(","),
+            flag("LeftHanded"),
+            flag("IsBaby") || matches!(mob.get("Age"), Some(Tag::Int(a)) if *a < 0),
+        )
+    }
+    /// The described entities of chunk (x, z) after decorating the 3x3 around it.
+    fn chunk_mobs(
+        root: &std::path::Path,
+        seed: i64,
+        dimension: &str,
+        x: i32,
+        z: i32,
+    ) -> Vec<String> {
+        use crate::streaming::{ChunkGenerator, Proto};
+        let assets = crate::assets::Assets::load(root).unwrap();
+        let biomes = crate::biome::Biomes::load(root).unwrap();
+        let terrain = super::super::VanillaTerrain::for_dimension(
+            &root.join("worldgen"),
+            assets.registry,
+            &biomes,
+            seed,
+            dimension,
+        )
+        .unwrap();
+        let mut worker = terrain.worker();
+        let mut region: [Proto; 9] = std::array::from_fn(|i| {
+            terrain.proto(&mut worker, x + i as i32 % 3 - 1, z + i as i32 / 3 - 1)
+        });
+        terrain.decorate(&mut worker, &mut region);
+        let center = std::mem::replace(&mut region[4], Box::new(()));
+        let mut got: Vec<String> = terrain
+            .finish(center)
+            .entities
+            .iter()
+            .map(describe)
+            .collect();
+        got.sort();
+        got
+    }
+    /// Seed 12345's bastion at chunk (-21, 8): the mobs of chunk (-23, 8) as two
+    /// vanilla 26.3 runs saved them (weapons and armour, hunting memory, follow
+    /// range bonus, handedness), from the region random of that chunk. The
+    /// memories are as placed: vanilla saved them 13 brain ticks later.
+    #[test]
+    fn bastion_chunk_mobs_match_vanilla() {
+        let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES").map(PathBuf::from) else {
+            return;
+        };
+        let got = chunk_mobs(&root, 12345, "minecraft:the_nether", -23, 8);
+        let mut expected = [
+            "piglin golden_sword,-,golden_chestplate,-,- ttl=1760 bonus=0.013784",
+            "piglin crossbow,-,-,-,- ttl=806 bonus=-0.011458",
+            "piglin golden_sword,-,-,-,- ttl=1315 bonus=-0.084585",
+            "piglin golden_sword,-,-,-,- ttl=1489 bonus=-0.038292",
+            "piglin_brute golden_axe,-,-,-,- ttl=- bonus=-0.020574",
+            "piglin crossbow,-,-,-,- ttl=1620 bonus=-0.079135",
+            "hoglin -,-,-,-,- ttl=- bonus=-0.012052",
+            "piglin golden_sword,-,-,-,- ttl=783 bonus=-0.077071",
+            "piglin crossbow,-,-,golden_leggings,- ttl=1431 bonus=0.007058",
+        ]
+        .map(|e| format!("{e} left=false baby=false"));
+        expected.sort();
+        assert_eq!(got, expected);
+    }
+
+    /// Seed 12345's ocean ruin at (53, 39, 424): Drowned.finalizeSpawn mounts the
+    /// trident drowned on a zombie nautilus, as vanilla saved chunk (3, 26).
+    #[test]
+    fn ocean_ruin_drowned_match_vanilla() {
+        let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES").map(PathBuf::from) else {
+            return;
+        };
+        let got = chunk_mobs(&root, 12345, "minecraft:overworld", 3, 26);
+        let d = |gear: &str, bonus: &str| {
+            format!("drowned {gear},-,-,-,- ttl=- bonus={bonus} left=false baby=false")
+        };
+        let mut expected = vec![
+            d("-", "0.001996"),
+            format!(
+                "zombie_nautilus -,-,-,-,- ttl=- bonus=-0.044983 left=false baby=false [{}]",
+                d("trident", "-0.045604")
+            ),
+            d("fishing_rod", "-0.059079"),
+            d("-", "0.021658"),
+        ];
+        expected.sort();
+        assert_eq!(got, expected);
+    }
+}
diff --git a/crates/horizon-client/src/world.rs b/crates/horizon-client/src/world.rs
index 83083eba2..27e1417d6 100644
--- a/crates/horizon-client/src/world.rs
+++ b/crates/horizon-client/src/world.rs
@@ -53,7 +53,7 @@ pub struct World {
     pub chunks: crate::chunk_map::ChunkMap,
     pub random: LegacyRandom,
     pub revision: u64,
-    pub health_rules: crate::health::HealthRules,
+    pub health_rules: HealthRules,
     pub air: BlockStateId,
     /// Sections whose geometry changed and need remeshing.
     pub dirty_sections: DirtySections,
@@ -92,12 +92,14 @@ pub struct World {
     /// (`ChunkHolder.sectionLightChanged`).
     pub light_log: Option<crate::fast_hash::FxHashMap<(i32, i32), u32>>,
     /// The villager POIs of each section (`PoiManager`'s sections).
-    pub pois: crate::poi_sections::PoiSections<crate::mobs::villager_brain::Poi>,
+    pub pois: crate::poi_sections::PoiSections<crate::poi_sections::Poi>,
+    /// Moving-piston states removed during the last tick; retained until the
+    /// final block mesh is visible.
+    pub moving_piston_fallback: Vec<([i32; 3], horizon_world::piston_shape::MovingPistonState)>,
     /// The moving-piston block entities of the level, by position, copied
     /// from the block ticks after each tick: collision and rendering read them.
     pub moving_pistons: Vec<([i32; 3], horizon_world::piston_shape::MovingPistonState)>,
 }
-/// ServerLevel weather state (advanceWeatherCycle).
 #[derive(Clone, Copy, Debug, Default)]
 pub struct Weather {
     pub clear_time: i32,
@@ -168,7 +170,7 @@ impl World {
             chunks: Default::default(),
             random: LegacyRandom::new(seed),
             revision: 0,
-            health_rules: crate::health::HealthRules::default(),
+            health_rules: HealthRules::default(),
             air,
             fast_lava: false,
             dirty_sections: Default::default(),
@@ -187,6 +189,7 @@ impl World {
             weather: Weather::default(),
             block_log: None,
             light_log: None,
+            moving_piston_fallback: Vec::new(),
             moving_pistons: Vec::new(),
             pois: Default::default(),
         }
@@ -374,6 +377,32 @@ impl World {
     }
 }
 
+/// The game rules and difficulty a player's health reads (`Player.isInvulnerableTo`,
+/// natural regeneration), kept with the world they belong to.
+#[derive(Clone, Copy, Debug)]
+pub struct HealthRules {
+    pub difficulty: horizon_world::food::Difficulty,
+    pub natural_regeneration: bool,
+    /// The `drowning_damage`, `fall_damage`, `fire_damage` and
+    /// `freeze_damage` rules `Player.isInvulnerableTo` reads.
+    pub drowning_damage: bool,
+    pub fall_damage: bool,
+    pub fire_damage: bool,
+    pub freeze_damage: bool,
+}
+impl Default for HealthRules {
+    fn default() -> Self {
+        Self {
+            difficulty: horizon_world::food::Difficulty::Normal,
+            natural_regeneration: true,
+            drowning_damage: true,
+            fall_damage: true,
+            fire_damage: true,
+            freeze_damage: true,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::World;
diff --git a/crates/horizon-client/tests/lan_bot.rs b/crates/horizon-client/tests/lan_bot.rs
index 34e8265a1..40488faa7 100644
--- a/crates/horizon-client/tests/lan_bot.rs
+++ b/crates/horizon-client/tests/lan_bot.rs
@@ -186,6 +186,7 @@ impl Server {
             attributes: Vec::new(),
             bed: None,
             living_flags: 0,
+            body: Default::default(),
         };
         let mut ctx = TickCtx {
             world: &mut self.world,
@@ -278,6 +279,75 @@ fn run<T: Send + 'static>(
     handle.join().unwrap().unwrap()
 }
 
+#[test]
+fn recipe_settings_packets_update_only_the_players_book_and_survive_save() {
+    let Some(resources) = resources() else {
+        return;
+    };
+    let mut s = server(&resources);
+    let port = s.hub.lan.port;
+    let _bot = run(&mut s, move || connect(port, "RecipeSettings", true));
+    let deadline = Instant::now() + Duration::from_secs(5);
+    while s.hub.guests.is_empty() {
+        s.tick(&[]);
+        assert!(Instant::now() < deadline, "guest did not join");
+        thread::yield_now();
+    }
+    for book in 0..4 {
+        for flags in 0..4 {
+            let open = flags & 1 != 0;
+            let filtering = flags & 2 != 0;
+            let before = s.hub.guests[0].recipe_book.clone();
+            // Vanilla's wire payload: RecipeBookType VarInt, open, filtering.
+            let packet = S::decode(
+                horizon_protocol::ids::play::serverbound::RECIPE_BOOK_CHANGE_SETTINGS,
+                &[book, u8::from(open), u8::from(filtering)],
+            )
+            .unwrap();
+            s.hub.guests[0].inbox.push_back(packet);
+            s.tick(&[]);
+            let settings = &s.hub.guests[0].recipe_book;
+            for i in 0..4 {
+                assert_eq!(
+                    settings.open[i],
+                    if i == usize::from(book) {
+                        open
+                    } else {
+                        before.open[i]
+                    }
+                );
+                assert_eq!(
+                    settings.filtering[i],
+                    if i == usize::from(book) {
+                        filtering
+                    } else {
+                        before.filtering[i]
+                    }
+                );
+            }
+            let mut saved = horizon_client::save::Level::default();
+            horizon_client::lan::playerdata::store(&s.hub.guests[0], &mut saved);
+            let mut reopened = horizon_client::save::Level::default();
+            reopened.read_player(&saved.player_tag());
+            assert_eq!(reopened.recipe_book.open, settings.open);
+            assert_eq!(reopened.recipe_book.filtering, settings.filtering);
+        }
+    }
+    for book_type in [-1, 4] {
+        let mut wire = horizon_protocol::buf::Writer::new();
+        wire.varint(book_type);
+        wire.bool(true);
+        wire.bool(true);
+        assert!(
+            S::decode(
+                horizon_protocol::ids::play::serverbound::RECIPE_BOOK_CHANGE_SETTINGS,
+                &wire.data,
+            )
+            .is_err()
+        );
+    }
+}
+
 #[test]
 fn sprint_commands_survive_keyboard_input_changes() {
     let Some(resources) = resources() else {
diff --git a/crates/horizon-command/Cargo.toml b/crates/horizon-command/Cargo.toml
new file mode 100644
index 000000000..10191ed6f
--- /dev/null
+++ b/crates/horizon-command/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "horizon-command"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+rust-version = "1.90"
+description = "Commands (Brigadier): the vanilla command tree, argument types, selectors, parsing, suggestions and the network form of the tree"
+
+[dependencies]
+horizon-client-core = { path = "../horizon-client-core" }
+horizon-protocol = { path = "../horizon-protocol" }
+horizon-world = { path = "../horizon-world" }
+
+[lints]
+workspace = true
diff --git a/crates/horizon-client/src/command/args.rs b/crates/horizon-command/src/args.rs
similarity index 87%
rename from crates/horizon-client/src/command/args.rs
rename to crates/horizon-command/src/args.rs
index ccced67a7..9b665e25b 100644
--- a/crates/horizon-client/src/command/args.rs
+++ b/crates/horizon-command/src/args.rs
@@ -1,192 +1,8 @@
 //! Argument types (Brigadier's and Minecraft's `ArgumentType`s): parsing with
 //! the vanilla error messages and completion suggestions.
 use super::{CmdResult, CommandError, Context, Reader, SuggestionsBuilder};
-use std::collections::BTreeMap;
 
-/// Registry contents and source state used to validate and complete arguments.
-#[derive(Clone, Debug, Default)]
-pub struct Registries {
-    /// Permission level of the command source.
-    pub permission: u8,
-    pub items: Vec<String>,
-    pub item_tags: Vec<String>,
-    /// Block id -> (property, allowed values).
-    pub blocks: BTreeMap<String, Vec<(String, Vec<String>)>>,
-    pub block_tags: Vec<String>,
-    /// Entity types that `summon` can create.
-    pub summonable: Vec<String>,
-    /// Every entity type (selector `type=`).
-    pub entity_types: Vec<String>,
-    pub effects: Vec<String>,
-    pub enchantments: Vec<String>,
-    pub structures: Vec<String>,
-    pub biomes: Vec<String>,
-    pub dimensions: Vec<String>,
-    pub clocks: Vec<String>,
-    pub timelines: Vec<String>,
-    pub time_markers: Vec<String>,
-    pub advancements: Vec<String>,
-    /// Game rule name -> integer-valued.
-    pub game_rules: Vec<(String, bool)>,
-    pub players: Vec<String>,
-    /// Scoreboard objective names, team names and tracked score holders.
-    pub objectives: Vec<String>,
-    pub teams: Vec<String>,
-    pub tracked: Vec<String>,
-    /// Loaded datapack functions (`ns:path`) and function tags (`ns:path`).
-    pub functions: Vec<String>,
-    /// `/data ... storage` ids.
-    pub storages: Vec<String>,
-    /// Boss bar ids and datapack predicate ids.
-    pub bossbars: Vec<String>,
-    pub predicates: Vec<String>,
-    pub item_modifiers: Vec<String>,
-    pub schedules: Vec<String>,
-    pub stopwatches: Vec<String>,
-    pub recipes: Vec<String>,
-    pub sounds: Vec<String>,
-    pub damage_types: Vec<String>,
-    pub attributes: Vec<String>,
-    pub loot_tables: Vec<String>,
-    pub templates: Vec<String>,
-    pub random_sequences: Vec<String>,
-    pub datapacks_enabled: Vec<String>,
-    pub datapacks_disabled: Vec<String>,
-    pub function_tags: Vec<String>,
-    /// The block the source is looking at (relevant coordinates).
-    pub target_block: Option<[i32; 3]>,
-    /// Every registry's element and tag ids (`minecraft:item` -> ...), as
-    /// the server's registry access and reloadable registries hold them.
-    pub by_registry: BTreeMap<String, RegistryIds>,
-    /// Blocks whose default state has a block entity.
-    pub block_entities: std::collections::BTreeSet<String>,
-    /// Block tag -> member blocks.
-    pub block_tag_members: BTreeMap<String, Vec<String>>,
-    /// Data component types with a codec (not transient).
-    pub persistent_components: Vec<String>,
-    /// Recipes `/recipe` can give (not special).
-    pub learnable_recipes: Vec<String>,
-    /// Advancement id -> criterion names.
-    pub advancement_criteria: BTreeMap<String, Vec<String>>,
-    /// World clock -> time markers shown in commands.
-    pub clock_time_markers: BTreeMap<String, Vec<String>>,
-    /// Trigger objectives the source may use (`/trigger` suggestions).
-    pub trigger_objectives: Vec<String>,
-    /// Objectives with the `trigger` criterion -> holder -> whether its score is locked.
-    pub trigger_scores: BTreeMap<String, BTreeMap<String, bool>>,
-}
-/// The ids and tag ids of one registry.
-#[derive(Clone, Debug, Default)]
-pub struct RegistryIds {
-    pub ids: Vec<String>,
-    pub tags: Vec<String>,
-}
-const EMPTY: &[String] = &[];
-impl Registries {
-    /// Fill what the game did not build itself from vanilla's exported
-    /// registries (`command-registries.json`, written by
-    /// `VanillaCommandParseOracle registries`): built-in registries such as
-    /// mob effects, data component types and dialogs, block entities and tag
-    /// members. Registries that data packs reload stay with the game.
-    pub fn fill_from_export(&mut self, r: &serde_json::Value) {
-        fn strings(v: &serde_json::Value) -> Vec<String> {
-            v.as_array()
-                .map(|a| {
-                    a.iter()
-                        .filter_map(|x| x.as_str().map(str::to_owned))
-                        .collect()
-                })
-                .unwrap_or_default()
-        }
-        let fill = |field: &mut Vec<String>, key: &str| {
-            if field.is_empty() {
-                *field = strings(&r[key]);
-            }
-        };
-        fill(&mut self.effects, "effects");
-        fill(&mut self.enchantments, "enchantments");
-        fill(&mut self.attributes, "attributes");
-        fill(&mut self.damage_types, "damage_types");
-        fill(&mut self.templates, "templates");
-        fill(&mut self.persistent_components, "persistent_components");
-        fill(&mut self.learnable_recipes, "learnable_recipes");
-        const RELOADED: [&str; 5] = [
-            "minecraft:advancement",
-            "minecraft:recipe",
-            "minecraft:loot_table",
-            "minecraft:predicate",
-            "minecraft:item_modifier",
-        ];
-        for (name, entry) in r["by_registry"].as_object().into_iter().flatten() {
-            if RELOADED.contains(&name.as_str()) || self.by_registry.contains_key(name) {
-                continue;
-            }
-            self.by_registry.insert(
-                name.clone(),
-                RegistryIds {
-                    ids: strings(&entry["ids"]),
-                    tags: strings(&entry["tags"]),
-                },
-            );
-        }
-        if self.block_entities.is_empty() {
-            self.block_entities = strings(&r["block_entities"]).into_iter().collect();
-        }
-        if self.block_tag_members.is_empty() {
-            for (tag, members) in r["block_tag_members"].as_object().into_iter().flatten() {
-                self.block_tag_members.insert(tag.clone(), strings(members));
-            }
-        }
-        if self.clock_time_markers.is_empty() {
-            for (clock, markers) in r["clock_time_markers"].as_object().into_iter().flatten() {
-                self.clock_time_markers
-                    .insert(clock.clone(), strings(markers));
-            }
-        }
-        if self.advancement_criteria.is_empty() {
-            for (id, criteria) in r["advancement_criteria"].as_object().into_iter().flatten() {
-                self.advancement_criteria
-                    .insert(id.clone(), strings(criteria));
-            }
-        }
-    }
-    /// The element ids of a registry (sorted).
-    pub fn ids(&self, registry: &str) -> &[String] {
-        if let Some(r) = self.by_registry.get(registry) {
-            return &r.ids;
-        }
-        match registry {
-            "minecraft:item" => &self.items,
-            "minecraft:entity_type" => &self.entity_types,
-            "minecraft:mob_effect" => &self.effects,
-            "minecraft:enchantment" => &self.enchantments,
-            "minecraft:worldgen/structure" => &self.structures,
-            "minecraft:worldgen/biome" => &self.biomes,
-            "minecraft:world_clock" => &self.clocks,
-            "minecraft:timeline" => &self.timelines,
-            "minecraft:attribute" => &self.attributes,
-            "minecraft:damage_type" => &self.damage_types,
-            "minecraft:sound_event" => &self.sounds,
-            "minecraft:predicate" => &self.predicates,
-            "minecraft:item_modifier" => &self.item_modifiers,
-            "minecraft:loot_table" => &self.loot_tables,
-            "minecraft:recipe" => &self.recipes,
-            "minecraft:advancement" => &self.advancements,
-            _ => EMPTY,
-        }
-    }
-    /// The tag ids of a registry (sorted).
-    pub fn tags(&self, registry: &str) -> &[String] {
-        if let Some(r) = self.by_registry.get(registry) {
-            return &r.tags;
-        }
-        match registry {
-            "minecraft:item" => &self.item_tags,
-            "minecraft:block" => &self.block_tags,
-            _ => EMPTY,
-        }
-    }
-}
+pub use horizon_client_core::registries::{Registries, RegistryIds};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Resource {
@@ -551,6 +367,14 @@ impl Selector {
     pub fn single(&self) -> bool {
         self.limit <= 1
     }
+    /// `EntitySelectorParser.setWorldLimited`: a selector with a spatial
+    /// constraint (`distance` or a position) reaches the level the command
+    /// runs in only; an unbounded one reaches every loaded level.
+    pub fn world_limited(&self) -> bool {
+        self.distance.is_some()
+            || self.pos.iter().any(Option::is_some)
+            || self.delta.iter().any(Option::is_some)
+    }
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct BlockInput {
@@ -637,22 +461,7 @@ pub fn read_identifier(reader: &mut Reader) -> CmdResult<String> {
         }
     }
 }
-/// Identifier.parse: `ns:path` or `path`, validated.
-pub fn parse_identifier(raw: &str) -> Option<String> {
-    let (ns, path) = match raw.split_once(':') {
-        Some(("", path)) => ("minecraft", path),
-        Some((ns, path)) => (ns, path),
-        None => ("minecraft", raw),
-    };
-    let ns_ok = ns != ".."
-        && ns
-            .chars()
-            .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-'));
-    let path_ok = path.chars().all(|c| {
-        c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '_' | '.' | '-' | '/')
-    });
-    (ns_ok && path_ok).then(|| format!("{ns}:{path}"))
-}
+pub use horizon_client_core::identifier::parse_identifier;
 pub fn normalize(id: &str) -> String {
     match id.split_once(':') {
         Some(("", path)) => format!("minecraft:{path}"),
@@ -1220,7 +1029,10 @@ impl ArgType {
                     reader.cursor = start;
                     return Err(CommandError::tr_at(
                         "argument.float.low",
-                        &[&crate::snbt::java_float(*min), &crate::snbt::java_float(v)],
+                        &[
+                            &horizon_client_core::snbt::java_float(*min),
+                            &horizon_client_core::snbt::java_float(v),
+                        ],
                         reader,
                     ));
                 }
@@ -1228,7 +1040,10 @@ impl ArgType {
                     reader.cursor = start;
                     return Err(CommandError::tr_at(
                         "argument.float.big",
-                        &[&crate::snbt::java_float(*max), &crate::snbt::java_float(v)],
+                        &[
+                            &horizon_client_core::snbt::java_float(*max),
+                            &horizon_client_core::snbt::java_float(v),
+                        ],
                         reader,
                     ));
                 }
@@ -1241,8 +1056,8 @@ impl ArgType {
                     return Err(CommandError::tr_at(
                         "argument.double.low",
                         &[
-                            &crate::snbt::java_double(*min),
-                            &crate::snbt::java_double(v),
+                            &horizon_client_core::snbt::java_double(*min),
+                            &horizon_client_core::snbt::java_double(v),
                         ],
                         reader,
                     ));
@@ -1252,8 +1067,8 @@ impl ArgType {
                     return Err(CommandError::tr_at(
                         "argument.double.big",
                         &[
-                            &crate::snbt::java_double(*max),
-                            &crate::snbt::java_double(v),
+                            &horizon_client_core::snbt::java_double(*max),
+                            &horizon_client_core::snbt::java_double(v),
                         ],
                         reader,
                     ));
@@ -1597,7 +1412,7 @@ impl ArgType {
                     return Err(CommandError::tr_at(key, &[&m], reader));
                 }
                 let text = &reader.string[start..reader.cursor];
-                match crate::component::parse_snbt(text) {
+                match horizon_client_core::component::parse_snbt(text) {
                     Ok((v, _)) => Arg::Str(v.to_string()),
                     Err(_) => Arg::Str(text.to_owned()),
                 }
@@ -1645,7 +1460,7 @@ impl ArgType {
                 }
                 let id = &reader.string[start..reader.cursor];
                 // ObjectiveCriteria.byName: statistics resolve to their canonical name.
-                match crate::scoreboard::criteria_by_name(id, reg) {
+                match horizon_client_core::scoreboard::criteria_by_name(id, reg) {
                     Ok(Some(canonical)) => Arg::Str(canonical),
                     Ok(None) => {
                         reader.cursor = start;
@@ -1667,7 +1482,7 @@ impl ArgType {
             }
             ArgType::ScoreboardSlot => {
                 let name = reader.read_unquoted_string();
-                if !crate::scoreboard::display_slot_valid(name) {
+                if !horizon_client_core::scoreboard::display_slot_valid(name) {
                     return Err(CommandError::tr_at(
                         "argument.scoreboardDisplaySlot.invalid",
                         &[&name],
@@ -1695,7 +1510,7 @@ impl ArgType {
             }
             ArgType::TeamColor => {
                 let name = reader.read_unquoted_string();
-                if crate::scoreboard::team_color_rgb(name).is_none() {
+                if horizon_client_core::scoreboard::team_color_rgb(name).is_none() {
                     return Err(CommandError::tr_at(
                         "argument.color.invalid",
                         &[&name],
@@ -1743,7 +1558,7 @@ impl ArgType {
                 let id = read_identifier(reader)?;
                 let known = reg.ids("minecraft:particle_type");
                 let exists = if known.is_empty() {
-                    crate::particles::ParticleType::from_name(&id).is_some()
+                    horizon_client_core::particle_type::ParticleType::from_name(&id).is_some()
                 } else {
                     known.contains(&id)
                 };
@@ -1931,15 +1746,16 @@ impl ArgType {
             }
             ArgType::Team => builder.suggest_matching(reg.teams.iter().map(String::as_str)),
             ArgType::Criteria => {
-                let mut ids: Vec<String> = crate::scoreboard::CUSTOM_CRITERIA
+                let mut ids: Vec<String> = horizon_client_core::scoreboard::CUSTOM_CRITERIA
                     .iter()
                     .map(|s| (*s).to_owned())
                     .collect();
-                for c in crate::scoreboard::team_colors() {
+                for c in horizon_client_core::scoreboard::team_colors() {
                     ids.push(format!("teamkill.{c}"));
                     ids.push(format!("killedByTeam.{c}"));
                 }
-                let stat = |ty: &str, key: &str| crate::scoreboard::stat_criteria(ty, key);
+                let stat =
+                    |ty: &str, key: &str| horizon_client_core::scoreboard::stat_criteria(ty, key);
                 ids.extend(reg.blocks.keys().map(|b| stat("mined", b)));
                 for ty in ["crafted", "used", "broken", "picked_up", "dropped"] {
                     ids.extend(reg.items.iter().map(|i| stat(ty, i)));
@@ -1948,14 +1764,14 @@ impl ArgType {
                     ids.extend(reg.entity_types.iter().map(|e| stat(ty, e)));
                 }
                 ids.extend(
-                    crate::scoreboard::CUSTOM_STATS
+                    horizon_client_core::scoreboard::CUSTOM_STATS
                         .iter()
                         .map(|c| stat("custom", &format!("minecraft:{c}"))),
                 );
                 builder.suggest_matching(ids.iter().map(String::as_str));
             }
             ArgType::ScoreboardSlot => {
-                let slots = crate::scoreboard::display_slots();
+                let slots = horizon_client_core::scoreboard::display_slots();
                 builder.suggest_matching(slots.iter().map(String::as_str));
             }
             ArgType::Operation => builder.suggest_matching(OPERATIONS),
@@ -1963,7 +1779,7 @@ impl ArgType {
             ArgType::Particle => {
                 let known = reg.ids("minecraft:particle_type");
                 if known.is_empty() {
-                    let names: Vec<String> = crate::particles::ParticleType::ALL
+                    let names: Vec<String> = horizon_client_core::particle_type::ParticleType::ALL
                         .iter()
                         .map(|t| format!("minecraft:{}", t.name()))
                         .collect();
@@ -1999,7 +1815,9 @@ impl ArgType {
                 suggest_resources(builder, reg.ids("minecraft:slot_source"), "");
             }
             ArgType::ResourceOrId(registry) => suggest_resources(builder, reg.ids(registry), ""),
-            ArgType::TeamColor => builder.suggest_matching(crate::scoreboard::team_colors()),
+            ArgType::TeamColor => {
+                builder.suggest_matching(horizon_client_core::scoreboard::team_colors())
+            }
             ArgType::Anchor => builder.suggest_matching(["eyes", "feet"]),
             ArgType::Component | ArgType::Style | ArgType::NbtTag => super::snbt::suggest(builder),
             ArgType::Swizzle | ArgType::Message | ArgType::Nbt => {}
diff --git a/crates/horizon-client/src/command/block.rs b/crates/horizon-command/src/block.rs
similarity index 100%
rename from crates/horizon-client/src/command/block.rs
rename to crates/horizon-command/src/block.rs
diff --git a/crates/horizon-client/src/command/codec.rs b/crates/horizon-command/src/codec.rs
similarity index 99%
rename from crates/horizon-client/src/command/codec.rs
rename to crates/horizon-command/src/codec.rs
index 7c4d26682..40f5c1ce0 100644
--- a/crates/horizon-client/src/command/codec.rs
+++ b/crates/horizon-command/src/codec.rs
@@ -6,7 +6,7 @@ use super::{CmdResult, CommandError, Reader};
 use horizon_world::nbt::{Compound, JavaString, Tag};
 
 pub fn snbt(t: &Tag) -> String {
-    crate::snbt::to_snbt(t)
+    horizon_client_core::snbt::to_snbt(t)
 }
 pub fn not_map(t: &Tag) -> String {
     format!("Not a map: {}", snbt(t))
diff --git a/crates/horizon-client/src/command/component.rs b/crates/horizon-command/src/component.rs
similarity index 98%
rename from crates/horizon-client/src/command/component.rs
rename to crates/horizon-command/src/component.rs
index 15a8fa6a0..2933afeca 100644
--- a/crates/horizon-client/src/command/component.rs
+++ b/crates/horizon-command/src/component.rs
@@ -164,7 +164,7 @@ fn color(t: &Tag) -> R {
             _ => partial(format!("Invalid color value: {s}")),
         };
     }
-    if crate::text::named_color(&s).is_some() {
+    if horizon_client_core::text::named_color(&s).is_some() {
         Ok(())
     } else {
         partial(format!("Invalid color name: {s}"))
@@ -278,7 +278,7 @@ fn content(kind: &str, map: &Compound) -> bool {
         "nbt" => {
             let path_ok = get(map, "nbt")
                 .and_then(string_of)
-                .is_some_and(|p| crate::nbt_path::NbtPath::parse(&p).is_ok());
+                .is_some_and(|p| horizon_client_core::nbt_path::NbtPath::parse(&p).is_ok());
             let source = if let Some(e) = get(map, "entity") {
                 selector_string(e)
             } else if let Some(b) = get(map, "block") {
diff --git a/crates/horizon-client/src/command/item.rs b/crates/horizon-command/src/item.rs
similarity index 99%
rename from crates/horizon-client/src/command/item.rs
rename to crates/horizon-command/src/item.rs
index f2abc91ef..da9c4b8b0 100644
--- a/crates/horizon-client/src/command/item.rs
+++ b/crates/horizon-command/src/item.rs
@@ -72,9 +72,9 @@ pub fn decode_component(id: &str, t: &Tag) -> Result<(), String> {
                     } else {
                         format!("minecraft:{id}")
                     };
-                    let known = crate::block_entity_nbt::TYPES
+                    let known = horizon_client_core::block_entity_nbt::TYPES
                         .iter()
-                        .chain(&crate::block_entity_nbt::NEWEST)
+                        .chain(&horizon_client_core::block_entity_nbt::NEWEST)
                         .any(|k| *k == id);
                     if known {
                         Ok(())
diff --git a/crates/horizon-client/src/command/mod.rs b/crates/horizon-command/src/lib.rs
similarity index 99%
rename from crates/horizon-client/src/command/mod.rs
rename to crates/horizon-command/src/lib.rs
index a61c8c08d..838c8de87 100644
--- a/crates/horizon-client/src/command/mod.rs
+++ b/crates/horizon-command/src/lib.rs
@@ -3,6 +3,7 @@
 //! relevant child and keeps the best result, completion suggestions, smart
 //! usage text and the vanilla error messages. Argument types live in
 //! [`args`]; the vanilla command tree in [`vanilla`].
+#![forbid(unsafe_code)]
 pub mod args;
 pub mod block;
 pub mod codec;
@@ -21,8 +22,8 @@ pub mod tree_world;
 pub mod vanilla;
 mod vanilla_order;
 
-use crate::text::Text;
 pub use args::{Arg, ArgType, Registries};
+use horizon_client_core::text::Text;
 
 /// The command id of a mod's command (`Dispatcher::with_mod_commands`).
 pub const MOD_COMMAND: &str = "mod";
@@ -623,8 +624,10 @@ impl Suggests {
                 for id in &reg.summonable {
                     if args::resource_matches(&contents, id) {
                         let (ns, path) = id.split_once(':').unwrap_or(("minecraft", id));
-                        let name =
-                            crate::lang::get(&format!("entity.{ns}.{}", path.replace('/', ".")));
+                        let name = horizon_client_core::lang::get(&format!(
+                            "entity.{ns}.{}",
+                            path.replace('/', ".")
+                        ));
                         builder.suggest_tooltip(id.clone(), name);
                     }
                 }
diff --git a/crates/horizon-client/src/command/network.rs b/crates/horizon-command/src/network.rs
similarity index 100%
rename from crates/horizon-client/src/command/network.rs
rename to crates/horizon-command/src/network.rs
diff --git a/crates/horizon-client/src/command/packrat.rs b/crates/horizon-command/src/packrat.rs
similarity index 99%
rename from crates/horizon-client/src/command/packrat.rs
rename to crates/horizon-command/src/packrat.rs
index 42f42d9f4..ebe9df09d 100644
--- a/crates/horizon-client/src/command/packrat.rs
+++ b/crates/horizon-command/src/packrat.rs
@@ -402,7 +402,7 @@ impl<'g, V: Value> State<'g, V> {
                 Reason::Error(e) => e.clone(),
             };
         }
-        CommandError::new(crate::text::Text::literal("Failed to parse"))
+        CommandError::new(horizon_client_core::text::Text::literal("Failed to parse"))
     }
     /// CachedParseState.parse: a named rule, memoised per position.
     pub fn parse(&mut self, rule: RuleId) -> Option<V> {
diff --git a/crates/horizon-client/src/command/selector.rs b/crates/horizon-command/src/selector.rs
similarity index 99%
rename from crates/horizon-client/src/command/selector.rs
rename to crates/horizon-command/src/selector.rs
index eb4e637a4..777124f60 100644
--- a/crates/horizon-client/src/command/selector.rs
+++ b/crates/horizon-command/src/selector.rs
@@ -687,7 +687,7 @@ impl<'r, 'a> SelectorParser<'r, 'a> {
 
     fn fill_selectors(builder: &mut SuggestionsBuilder) {
         for (s, tip) in SELECTOR_KINDS {
-            builder.suggest_tooltip(s, crate::lang::get(tip));
+            builder.suggest_tooltip(s, horizon_client_core::lang::get(tip));
         }
     }
 
@@ -785,7 +785,9 @@ impl<'r, 'a> SelectorParser<'r, 'a> {
             if self.can_use(o) && o.starts_with(&lower) {
                 b.suggest_tooltip(
                     format!("{o}="),
-                    crate::lang::get(&format!("argument.entity.options.{o}.description")),
+                    horizon_client_core::lang::get(&format!(
+                        "argument.entity.options.{o}.description"
+                    )),
                 );
             }
         }
diff --git a/crates/horizon-client/src/command/snbt.rs b/crates/horizon-command/src/snbt.rs
similarity index 100%
rename from crates/horizon-client/src/command/snbt.rs
rename to crates/horizon-command/src/snbt.rs
diff --git a/crates/horizon-client/src/command/tests.rs b/crates/horizon-command/src/tests.rs
similarity index 100%
rename from crates/horizon-client/src/command/tests.rs
rename to crates/horizon-command/src/tests.rs
diff --git a/crates/horizon-client/src/command/tree_data.rs b/crates/horizon-command/src/tree_data.rs
similarity index 100%
rename from crates/horizon-client/src/command/tree_data.rs
rename to crates/horizon-command/src/tree_data.rs
diff --git a/crates/horizon-client/src/command/tree_execute.rs b/crates/horizon-command/src/tree_execute.rs
similarity index 100%
rename from crates/horizon-client/src/command/tree_execute.rs
rename to crates/horizon-command/src/tree_execute.rs
diff --git a/crates/horizon-client/src/command/tree_extra.rs b/crates/horizon-command/src/tree_extra.rs
similarity index 100%
rename from crates/horizon-client/src/command/tree_extra.rs
rename to crates/horizon-command/src/tree_extra.rs
diff --git a/crates/horizon-client/src/command/tree_misc.rs b/crates/horizon-command/src/tree_misc.rs
similarity index 99%
rename from crates/horizon-client/src/command/tree_misc.rs
rename to crates/horizon-command/src/tree_misc.rs
index a66fd5f37..1bcd880bb 100644
--- a/crates/horizon-client/src/command/tree_misc.rs
+++ b/crates/horizon-command/src/tree_misc.rs
@@ -230,12 +230,12 @@ fn bossbar(d: &mut Dispatcher, root: usize) {
     let name = d.argument(name_l, "name", ArgType::Component);
     d.executes(name, "bossbar.set.name");
     let color = d.literal(id, "color");
-    for c in crate::bossbar::COLORS {
+    for c in horizon_client_core::bossbar::COLORS {
         let l = d.literal(color, c);
         d.executes(l, "bossbar.set.color");
     }
     let style = d.literal(id, "style");
-    for s in crate::bossbar::STYLES {
+    for s in horizon_client_core::bossbar::STYLES {
         let l = d.literal(style, s);
         d.executes(l, "bossbar.set.style");
     }
diff --git a/crates/horizon-client/src/command/tree_scoreboard.rs b/crates/horizon-command/src/tree_scoreboard.rs
similarity index 100%
rename from crates/horizon-client/src/command/tree_scoreboard.rs
rename to crates/horizon-command/src/tree_scoreboard.rs
diff --git a/crates/horizon-client/src/command/tree_world.rs b/crates/horizon-command/src/tree_world.rs
similarity index 99%
rename from crates/horizon-client/src/command/tree_world.rs
rename to crates/horizon-command/src/tree_world.rs
index 0bd2edd3b..86ebba0ca 100644
--- a/crates/horizon-client/src/command/tree_world.rs
+++ b/crates/horizon-command/src/tree_world.rs
@@ -7,7 +7,7 @@ use super::{
     args::{ArgType, integer},
     vanilla::{ENTITIES, ENTITY, GAMEMASTERS, PLAYERS},
 };
-use crate::settings::SOUND_SOURCES;
+use horizon_client_core::sound_source::SOUND_SOURCES;
 
 fn float(min: f32) -> ArgType {
     ArgType::Float { min, max: f32::MAX }
diff --git a/crates/horizon-client/src/command/vanilla.rs b/crates/horizon-command/src/vanilla.rs
similarity index 99%
rename from crates/horizon-client/src/command/vanilla.rs
rename to crates/horizon-command/src/vanilla.rs
index 2ce892077..37ec1c3de 100644
--- a/crates/horizon-client/src/command/vanilla.rs
+++ b/crates/horizon-command/src/vanilla.rs
@@ -5,7 +5,7 @@ use super::{
     Dispatcher,
     args::{ArgType, Resource, integer},
 };
-use crate::gamerules::{RULES, Value};
+use horizon_client_core::gamerules::{RULES, Value};
 
 /// Permission levels (Commands.LEVEL_*).
 pub const ALL: u8 = 0;
diff --git a/crates/horizon-client/src/command/vanilla_order.rs b/crates/horizon-command/src/vanilla_order.rs
similarity index 100%
rename from crates/horizon-client/src/command/vanilla_order.rs
rename to crates/horizon-command/src/vanilla_order.rs
diff --git a/crates/horizon-mod-sdk/examples/beacons/Cargo.toml b/crates/horizon-mod-sdk/examples/beacons/Cargo.toml
new file mode 100644
index 000000000..c001614e8
--- /dev/null
+++ b/crates/horizon-mod-sdk/examples/beacons/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "beacons"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+publish = false
+description = "Example Horizon server mod: /beacon lights a pillar beside you, /ground says what you stand on"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+horizon-mod-sdk = { path = "../.." }
+
+[lints]
+workspace = true
diff --git a/crates/horizon-mod-sdk/examples/beacons/horizon-mod.toml b/crates/horizon-mod-sdk/examples/beacons/horizon-mod.toml
new file mode 100644
index 000000000..5b58273c6
--- /dev/null
+++ b/crates/horizon-mod-sdk/examples/beacons/horizon-mod.toml
@@ -0,0 +1,8 @@
+id = "beacons"
+name = "Beacons"
+version = "0.1.0"
+description = "/beacon [height] lights a pillar of glowstone beside you; /ground [pos] says what you are standing on (or what is at pos), and in which biome."
+authors = ["Horizon"]
+api = "0.3"
+side = "server"
+capabilities = ["players", "world"]
diff --git a/crates/horizon-mod-sdk/examples/beacons/src/lib.rs b/crates/horizon-mod-sdk/examples/beacons/src/lib.rs
new file mode 100644
index 000000000..4a4de5cc1
--- /dev/null
+++ b/crates/horizon-mod-sdk/examples/beacons/src/lib.rs
@@ -0,0 +1,103 @@
+//! Example Horizon server mod (`docs/mods.md`, "Server mods") with
+//! capability `world` and typed commands: `/beacon [height]` lights a
+//! pillar of glowstone two blocks east of the player, `/ground [pos]` reads
+//! the block under their feet (or at `pos`) and its biome.
+use horizon_mod_sdk::server::{
+    Args, Argument, BlockChange, Player, Registration, ServerMod, players, world,
+};
+
+/// How tall `/beacon` builds when no height is given.
+const HEIGHT: i32 = 4;
+
+struct Beacons;
+
+/// The block the player stands in: their feet, floored.
+fn feet(player: &Player) -> (i32, i32, i32) {
+    (
+        player.x.floor() as i32,
+        player.y.floor() as i32,
+        player.z.floor() as i32,
+    )
+}
+
+/// The pillar beside `player`: `height` blocks of glowstone, from their feet up.
+fn pillar(player: &Player, height: i32) -> Vec<BlockChange> {
+    let (x, y, z) = feet(player);
+    (0..height)
+        .map(|dy| BlockChange {
+            x: x + 2,
+            y: y + dy,
+            z,
+            state: "minecraft:glowstone".into(),
+        })
+        .collect()
+}
+
+impl ServerMod for Beacons {
+    fn init() -> Result<(Self, Registration), String> {
+        Ok((
+            Beacons,
+            Registration::new()
+                .command_with(
+                    "beacon",
+                    [Argument::integer("height", Some(1), Some(64)).optional()],
+                )
+                .command_with("ground", [Argument::block_pos("pos").optional()]),
+        ))
+    }
+
+    fn command(
+        &mut self,
+        player: &Player,
+        name: &str,
+        args: &Args,
+    ) -> Result<Option<String>, String> {
+        let (x, y, z) = feet(player);
+        if name == "beacon" {
+            let height = args.integer("height").unwrap_or(HEIGHT);
+            world::set_blocks(&player.dimension, &pillar(player, height))?;
+            players::broadcast(&format!(
+                "{} lit a beacon at {} {y} {z}",
+                player.name,
+                x + 2
+            ));
+            return Ok(None);
+        }
+        let (bx, by, bz) = match args.block_pos("pos") {
+            Some(p) => (p.x, p.y, p.z),
+            None => (x, y - 1, z),
+        };
+        let block =
+            world::get_block(&player.dimension, bx, by, bz).ok_or("That block isn't loaded")?;
+        let biome = world::get_biome(&player.dimension, bx, by, bz).unwrap_or_default();
+        if args.block_pos("pos").is_some() {
+            return Ok(Some(format!("{bx} {by} {bz} is {block} in {biome}")));
+        }
+        Ok(Some(format!("You are standing on {block} in {biome}")))
+    }
+}
+
+horizon_mod_sdk::export_server_mod!(Beacons);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_pillar_stands_two_blocks_east() {
+        let p = Player {
+            id: String::new(),
+            name: "Alex".into(),
+            x: -0.5,
+            y: 64.0,
+            z: 3.2,
+            dimension: "minecraft:overworld".into(),
+            game_mode: horizon_mod_sdk::server::GameMode::Survival,
+            health: 20.0,
+        };
+        let blocks = pillar(&p, HEIGHT);
+        assert_eq!(blocks.len(), HEIGHT as usize);
+        assert_eq!((blocks[0].x, blocks[0].y, blocks[0].z), (1, 64, 3));
+        assert_eq!(blocks[3].y, 67);
+    }
+}
diff --git a/crates/horizon-mod-sdk/examples/beacons/tests/beacons.toml b/crates/horizon-mod-sdk/examples/beacons/tests/beacons.toml
new file mode 100644
index 000000000..bab4839f3
--- /dev/null
+++ b/crates/horizon-mod-sdk/examples/beacons/tests/beacons.toml
@@ -0,0 +1,39 @@
+# /ground [pos] reads the block under the player (or at pos) and the biome; /beacon [height] sets glowstone two to the east.
+
+[[step]]
+join = "Alex"
+blocks = [{ x = 0, y = 63, z = 0, state = "minecraft:grass_block[snowy=false]" }]
+command = "ground"
+expect.feedback = "You are standing on minecraft:grass_block[snowy=false] in minecraft:plains"
+
+[[step]]
+command = "beacon"
+expect.broadcast = ["Alex lit a beacon at 2 64 0"]
+expect.blocks = [
+    { x = 2, y = 64, z = 0, state = "minecraft:glowstone" },
+    { x = 2, y = 67, z = 0, state = "minecraft:glowstone" },
+    { x = 2, y = 68, z = 0, state = "minecraft:air" },
+]
+
+# Anywhere the script set nothing is air.
+[[step]]
+player = { x = 10.5, z = 10.5 }
+command = "ground"
+expect.feedback = "You are standing on minecraft:air in minecraft:plains"
+
+# Typed arguments: a height, a position relative to the player.
+[[step]]
+player = { x = 5.5, y = 64.0, z = 5.5 }
+command = "beacon 2"
+expect.blocks = [
+    { x = 7, y = 65, z = 5, state = "minecraft:glowstone" },
+    { x = 7, y = 66, z = 5, state = "minecraft:air" },
+]
+
+[[step]]
+command = "beacon 65"
+expect.error = "Integer must not be more than 64, found 65"
+
+[[step]]
+command = "ground ~2 ~1 ~"
+expect.feedback = "7 65 5 is minecraft:glowstone in minecraft:plains"
diff --git a/crates/horizon-mod-sdk/examples/welcome/src/lib.rs b/crates/horizon-mod-sdk/examples/welcome/src/lib.rs
index c45712c88..e5a5ef13e 100644
--- a/crates/horizon-mod-sdk/examples/welcome/src/lib.rs
+++ b/crates/horizon-mod-sdk/examples/welcome/src/lib.rs
@@ -1,9 +1,10 @@
 //! Example Horizon server mod (`docs/mods.md`, "Server mods"): greets each
 //! player who joins, announces a newcomer to everyone (the players it has
 //! seen are kept in `storage`), `/online` lists who is on and where, and
-//! `/mined` counts the blocks the player broke since the server started.
+//! `/mined [player]` counts the blocks a player broke since the server
+//! started (typed arguments: the chat box completes the player's name).
 use horizon_mod_sdk::{
-    server::{BlockPos, Player, Registration, ServerMod, players},
+    server::{Args, Argument, BlockPos, Player, Registration, ServerMod, players},
     storage,
 };
 use std::collections::HashMap;
@@ -25,8 +26,8 @@ impl ServerMod for Welcome {
             })
             .unwrap_or_default();
         let hooks = Registration::new()
-            .command("online")
-            .command("mined")
+            .command_with("online", [])
+            .command_with("mined", [Argument::player("player").optional()])
             .on_joins()
             .on_blocks();
         Ok((
@@ -55,7 +56,7 @@ impl ServerMod for Welcome {
         &mut self,
         player: &Player,
         name: &str,
-        _args: &str,
+        args: &Args,
     ) -> Result<Option<String>, String> {
         Ok(Some(match name {
             "online" => players::online()
@@ -69,10 +70,16 @@ impl ServerMod for Welcome {
                 })
                 .collect::<Vec<_>>()
                 .join(", "),
-            _ => {
-                let n = self.mined.get(&player.id).copied().unwrap_or(0);
-                format!("You broke {n} block(s)")
-            }
+            _ => match args.player("player") {
+                Some(other) if other.id != player.id => {
+                    let n = self.mined.get(&other.id).copied().unwrap_or(0);
+                    format!("{} broke {n} block(s)", other.name)
+                }
+                _ => {
+                    let n = self.mined.get(&player.id).copied().unwrap_or(0);
+                    format!("You broke {n} block(s)")
+                }
+            },
         }))
     }
 
diff --git a/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml b/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml
index 5f0018346..a55bd421d 100644
--- a/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml
+++ b/crates/horizon-mod-sdk/examples/welcome/tests/commands.toml
@@ -1,4 +1,4 @@
-# /online lists the players and their dimension; /mined counts the acting player's blocks.
+# /online lists the players and their dimension; /mined [player] counts a player's blocks.
 
 [[step]]
 join = "Alex"
@@ -29,3 +29,18 @@ expect.feedback = "You broke 2 block(s)"
 as = "Steve"
 command = "mined"
 expect.feedback = "You broke 0 block(s)"
+
+[[step]]
+as = "Steve"
+command = "mined alex"
+expect.feedback = "Alex broke 2 block(s)"
+
+# The server parses the arguments before the mod: vanilla's errors.
+[[step]]
+as = "Steve"
+command = "mined Herobrine"
+expect.error = "No player was found"
+
+[[step]]
+command = "online now"
+expect.error = "Incorrect argument for command"
diff --git a/crates/horizon-mod-sdk/src/lib.rs b/crates/horizon-mod-sdk/src/lib.rs
index 679fdc7b8..1e7120091 100644
--- a/crates/horizon-mod-sdk/src/lib.rs
+++ b/crates/horizon-mod-sdk/src/lib.rs
@@ -39,7 +39,9 @@ wit_bindgen::generate!({
 
 pub use exports::horizon::mods::events::{Guest as __Guest, Registration};
 pub use exports::horizon::mods::ui_events::Guest as __UiEventsGuest;
-pub use horizon::mods::{chat, command, game, hud, input, log, render, storage, ui};
+pub use horizon::mods::{
+    browser, chat, command, game, hud, input, log, recipes, render, storage, ui,
+};
 
 /// The game's calls into a mod. Only the hooks [`Registration`] asks for
 /// are called; the others may stay as their defaults.
@@ -192,8 +194,12 @@ pub mod server {
         },
     });
 
-    pub use exports::horizon::mods::server_events::{BlockPos, Guest as __Guest, Registration};
+    pub use exports::horizon::mods::server_events::{
+        Argument, ArgumentKind, ArgumentValue, BlockPos, Guest as __Guest, Registration,
+        ServerCommand,
+    };
     pub use horizon::mods::players::{self, GameMode, Player};
+    pub use horizon::mods::world::{self, BlockChange};
 
     /// The server's calls into a mod. Only the hooks [`Registration`] asks
     /// for are called; the others may stay as their defaults.
@@ -208,13 +214,14 @@ pub mod server {
         fn player_left(&mut self, _player: &Player) {}
         /// A chat message a player sent, when [`Registration::chat`] is set.
         fn chat(&mut self, _player: &Player, _text: &str) {}
-        /// `/name args` typed by `player`. `Ok(Some(text))` is their
-        /// feedback, `Err(text)` their error in red.
+        /// `/name args` typed by `player`, parsed as the command's
+        /// arguments say ([`Registration::command_with`]). `Ok(Some(text))`
+        /// is their feedback, `Err(text)` their error in red.
         fn command(
             &mut self,
             _player: &Player,
             _name: &str,
-            _args: &str,
+            _args: &Args,
         ) -> Result<Option<String>, String> {
             Err("This command does nothing".into())
         }
@@ -234,9 +241,23 @@ pub mod server {
                 blocks: false,
             }
         }
-        /// Adds `/name`.
-        pub fn command(mut self, name: &str) -> Self {
-            self.commands.push(name.into());
+        /// Adds `/name`, taking free text ([`Args::text`]): one optional
+        /// `text` argument named `args`.
+        pub fn command(self, name: &str) -> Self {
+            self.command_with(name, [Argument::text("args").optional()])
+        }
+        /// Adds `/name` with typed arguments (none: nothing after the name):
+        /// players' chat boxes complete and check them, and the server
+        /// parses them into [`Args`].
+        pub fn command_with(
+            mut self,
+            name: &str,
+            arguments: impl IntoIterator<Item = Argument>,
+        ) -> Self {
+            self.commands.push(ServerCommand {
+                name: name.into(),
+                arguments: arguments.into_iter().collect(),
+            });
             self
         }
         pub fn on_tick(mut self) -> Self {
@@ -261,6 +282,105 @@ pub mod server {
             Self::new()
         }
     }
+
+    impl Argument {
+        fn of(name: &str, kind: ArgumentKind) -> Self {
+            Self {
+                name: name.into(),
+                kind,
+                optional: false,
+            }
+        }
+        /// One word: letters, digits and `_ - . +`.
+        pub fn word(name: &str) -> Self {
+            Self::of(name, ArgumentKind::Word)
+        }
+        /// The rest of the line: only last.
+        pub fn text(name: &str) -> Self {
+            Self::of(name, ArgumentKind::Text)
+        }
+        /// A whole number, at least `min` and at most `max` when given.
+        pub fn integer(name: &str, min: Option<i32>, max: Option<i32>) -> Self {
+            Self::of(name, ArgumentKind::Integer((min, max)))
+        }
+        pub fn number(name: &str) -> Self {
+            Self::of(name, ArgumentKind::Number)
+        }
+        pub fn boolean(name: &str) -> Self {
+            Self::of(name, ArgumentKind::Boolean)
+        }
+        /// One online player: a name, `@s` or `@p`.
+        pub fn player(name: &str) -> Self {
+            Self::of(name, ArgumentKind::Player)
+        }
+        /// `x y z`, each one also `~` or `~n`.
+        pub fn block_pos(name: &str) -> Self {
+            Self::of(name, ArgumentKind::BlockPos)
+        }
+        /// May be left out; optional arguments come after the required ones.
+        pub fn optional(mut self) -> Self {
+            self.optional = true;
+            self
+        }
+    }
+
+    /// A command's arguments: the line as typed, and the values the server
+    /// parsed from it, by argument name.
+    #[derive(Clone, Debug, Default)]
+    pub struct Args {
+        text: String,
+        values: Vec<(String, ArgumentValue)>,
+    }
+    impl Args {
+        pub fn new(text: String, values: Vec<(String, ArgumentValue)>) -> Self {
+            Self { text, values }
+        }
+        /// The line after the command's name, as typed.
+        pub fn text(&self) -> &str {
+            &self.text
+        }
+        /// The value of argument `name`; `None` when it was left out.
+        pub fn get(&self, name: &str) -> Option<&ArgumentValue> {
+            self.values.iter().find(|(n, _)| n == name).map(|(_, v)| v)
+        }
+        pub fn integer(&self, name: &str) -> Option<i32> {
+            match self.get(name)? {
+                ArgumentValue::Integer(n) => Some(*n),
+                _ => None,
+            }
+        }
+        pub fn number(&self, name: &str) -> Option<f64> {
+            match self.get(name)? {
+                ArgumentValue::Number(n) => Some(*n),
+                _ => None,
+            }
+        }
+        /// A `word` or `text` argument.
+        pub fn string(&self, name: &str) -> Option<&str> {
+            match self.get(name)? {
+                ArgumentValue::Word(s) | ArgumentValue::Text(s) => Some(s),
+                _ => None,
+            }
+        }
+        pub fn boolean(&self, name: &str) -> Option<bool> {
+            match self.get(name)? {
+                ArgumentValue::Boolean(b) => Some(*b),
+                _ => None,
+            }
+        }
+        pub fn player(&self, name: &str) -> Option<&Player> {
+            match self.get(name)? {
+                ArgumentValue::Player(p) => Some(p),
+                _ => None,
+            }
+        }
+        pub fn block_pos(&self, name: &str) -> Option<BlockPos> {
+            match self.get(name)? {
+                ArgumentValue::BlockPos(p) => Some(*p),
+                _ => None,
+            }
+        }
+    }
 }
 
 /// Exports a [`ServerMod`](server::ServerMod) as the component's
@@ -270,7 +390,7 @@ macro_rules! export_server_mod {
     ($t:ty) => {
         const _: () = {
             use ::std::cell::RefCell;
-            use $crate::server::{BlockPos, Player, Registration, ServerMod};
+            use $crate::server::{Args, ArgumentValue, BlockPos, Player, Registration, ServerMod};
             ::std::thread_local! {
                 static STATE: RefCell<Option<$t>> = const { RefCell::new(None) };
             }
@@ -304,8 +424,10 @@ macro_rules! export_server_mod {
                     player: Player,
                     name: String,
                     args: String,
+                    values: Vec<(String, ArgumentValue)>,
                 ) -> Result<Option<String>, String> {
                     let mut out = Err("The mod is not running".to_string());
+                    let args = Args::new(args, values);
                     with(|m| out = m.command(&player, &name, &args));
                     out
                 }
diff --git a/crates/horizon-mod-sdk/wit/horizon.wit b/crates/horizon-mod-sdk/wit/horizon.wit
index d9bb9f5c2..0680cce92 100644
--- a/crates/horizon-mod-sdk/wit/horizon.wit
+++ b/crates/horizon-mod-sdk/wit/horizon.wit
@@ -412,6 +412,23 @@ interface render {
     /// own frame budget; hidden, they are dropped. One map shows at a time:
     /// the first loaded mod's.
     set-minimap: func(minimap: option<minimap>);
+    record far-terrain {
+        /// How far the distant terrain reaches, in chunks: 64 to 1024. On
+        /// integrated graphics other than Apple's the game caps it lower.
+        distance: u32,
+        /// Coarser far tiles, as the Far Detail setting's Reduced: 2 to 4 ms
+        /// less GPU time per frame on integrated graphics.
+        reduced: bool,
+    }
+    /// Draws the world beyond the render distance as distant terrain, out to
+    /// `distance` chunks, until the next call (none ends it). The game builds
+    /// it on its own workers, from the chunks already loaded or saved and,
+    /// where nobody has been, from the world's generator; the simulation
+    /// distance doesn't change. Only worlds whose generator the game has
+    /// (single player and a LAN world you host) show it. The player's own LOD
+    /// Distance setting, when on, wins. One far terrain shows at a time: the
+    /// first loaded mod's.
+    set-far-terrain: func(far-terrain: option<far-terrain>);
 }
 
 /// What the game calls. Only the hooks `init` asks for are ever called.
@@ -439,6 +456,181 @@ interface events {
     chat: func(text: string);
 }
 
+/// Capability `recipes` (experimental): the recipes and items the game
+/// knows, for recipe viewers. In single player and on Horizon's servers
+/// they are the world's; on any other server they are vanilla 26.3's (a
+/// client is sent no others), while `known` follows that server's book.
+interface recipes {
+    /// An item of `items`, by its index there, with a count and the
+    /// components it has beyond the item's own, in vanilla's item syntax
+    /// (`[potion_contents={potion:"minecraft:swiftness"}]`), or "".
+    record stack {
+        item: u32,
+        count: u32,
+        components: string,
+    }
+    /// The station a recipe is made at.
+    enum kind {
+        crafting-shaped,
+        crafting-shapeless,
+        smelting,
+        blasting,
+        smoking,
+        campfire,
+        stonecutting,
+        smithing,
+        brewing,
+    }
+    record recipe {
+        /// `minecraft:oak_planks`.
+        id: string,
+        kind: kind,
+        /// The recipe book's tab (`crafting_building_blocks`,
+        /// `furnace_food`), or "".
+        category: string,
+        /// Recipes the book shows on one button share a group, or "".
+        group: string,
+        /// A shaped recipe's grid: `slots` holds its cells row by row.
+        /// 0 for the other kinds.
+        width: u32,
+        height: u32,
+        /// Each slot's stacks, any one of which fits; an empty list is an
+        /// empty cell. Cooking and stonecutting: the input. Smithing: the
+        /// template, the base, the addition. Brewing: the bottle, the
+        /// reagent.
+        slots: list<list<stack>>,
+        /// What it makes; several when that varies (a trim on any armour).
+        results: list<stack>,
+        /// Cooking: game ticks and experience; 0 for the other kinds.
+        cooking-time: u32,
+        experience: f32,
+        /// The recipe book's id for it (one per way the book shows it), as
+        /// `known` lists them; -1 for the kinds the book doesn't show
+        /// (campfire, stonecutting, smithing, brewing).
+        book-id: s32,
+    }
+    record item {
+        /// `minecraft:diamond`, `<mod>:<path>`.
+        id: string,
+        /// In the player's language.
+        name: string,
+        /// Its item tags, without the `#`.
+        tags: list<string>,
+    }
+    /// Every item, in the registry's order: `stack.item` indexes this list.
+    items: func() -> list<item>;
+    /// Every recipe: the book's in its order, then campfire, stonecutting,
+    /// smithing and brewing. They don't change while a world is open.
+    all: func() -> list<recipe>;
+    /// The `book-id`s of the recipes the player's recipe book holds now.
+    known: func() -> list<s32>;
+    /// Places a recipe in the open screen's grid as a click in the recipe
+    /// book does (`ServerboundPlaceRecipePacket`): the inventory's grid or
+    /// a crafting table. `all` places as many as the items allow, as with
+    /// Shift. Refused while no such screen is open, for a recipe the
+    /// player's book doesn't hold and for one that can't be placed; one
+    /// missing items shows as a ghost in the grid, as in the book.
+    place: func(book-id: s32, all: bool) -> result<_, string>;
+    /// Creative mode only: gives the player the stack, as taking it from
+    /// the creative inventory does (`ServerboundSetCreativeModeSlot`): the
+    /// selected slot first, then the hotbar, then the inventory. The count
+    /// is cut to one stack of the item (64, 16 or 1).
+    give: func(stack: stack) -> result<_, string>;
+}
+
+/// Capability `ui` (experimental): a recipe viewer's panel beside the
+/// game's inventory and container screens (not the creative inventory), on
+/// the right of the screen. The game draws it with its own widgets and
+/// slots, pages it and keeps its search box; the mod says what it holds.
+/// The first loaded mod with a panel shows.
+interface browser {
+    /// An item to show: its id, a count (1 draws none) and its components
+    /// beyond the item's own, in vanilla's item syntax, or "".
+    record stack {
+        item: string,
+        count: u32,
+        components: string,
+    }
+    /// A click on an item of the panel, by its index in `set-items`'s list.
+    record click {
+        index: u32,
+        right: bool,
+    }
+    /// A key the mod registered (`input.register-key`) went down while the
+    /// pointer was on an item: a slot of the screen's, or the panel's.
+    record item-key {
+        key: string,
+        stack: stack,
+    }
+    /// A click on a slot of a recipe the panel shows (`set-recipes`).
+    record slot-click {
+        /// The recipe's index in `set-recipes`'s list and the slot's in
+        /// it; the results come after the slots.
+        recipe: u32,
+        slot: u32,
+        /// The stack the slot showed at that moment.
+        stack: stack,
+        right: bool,
+    }
+    variant event {
+        clicked(click),
+        /// The search box's text, each time the player changes it.
+        search(string),
+        key(item-key),
+        slot-clicked(slot-click),
+        /// The action button of the recipe at this index in
+        /// `set-recipes`'s list.
+        action(u32),
+        /// The player turned the recipes' page (`set-recipes`): the index
+        /// of the first recipe now shown.
+        page(u32),
+        /// The back button of `set-recipes`.
+        back,
+        /// The player picked the tab at this index of `set-recipes`' tabs.
+        tab(u32),
+    }
+    /// How the game lays out a recipe of `set-recipes`.
+    enum layout {
+        /// A crafting grid of `width` x `height` slots, an arrow and the
+        /// result.
+        grid,
+        /// One input over a flame, an arrow and the result (furnaces,
+        /// smokers, campfires).
+        cooking,
+        /// One input, an arrow and the result (the stonecutter).
+        single,
+        /// Template, base and addition, an arrow and the result.
+        smithing,
+        /// A potion and an ingredient, an arrow and the result.
+        brewing,
+    }
+    /// A recipe to show. Each slot, and the result, cycles through its
+    /// stacks, one a second; an empty slot shows nothing.
+    record recipe-view {
+        layout: layout,
+        /// The grid's size (`grid` only), at most 3 x 3.
+        width: u32,
+        height: u32,
+        slots: list<list<stack>>,
+        results: list<stack>,
+        /// A short line under the recipe (a cooking time), or "".
+        note: string,
+        /// The action button beside it: none, enabled, or shown greyed.
+        action: option<bool>,
+    }
+    /// The panel's items, at most 8192 (an empty list hides the panel).
+    set-items: func(items: list<stack>);
+    /// Shows these recipes in the panel instead of its items, as many as
+    /// fit a page, under `title` and a back button, with a row of `tabs`
+    /// (each an icon; `tab` is the selected one) between them; an empty
+    /// list of recipes shows the items again. At most 256 recipes and 16
+    /// tabs.
+    set-recipes: func(title: string, tabs: list<stack>, tab: u32, recipes: list<recipe-view>);
+    /// What the player did on the panel since the last poll, at most 256
+    /// kept.
+    poll: func() -> list<event>;
+}
+
 /// Capability `players`, server mods only (manifest `api = "0.3"`,
 /// experimental): the players on the server, and messages to them.
 interface players {
@@ -472,16 +664,94 @@ interface players {
     broadcast: func(text: string);
 }
 
+/// Capability `world`, server mods only (manifest `api = "0.3"`,
+/// experimental): the blocks of the server's loaded chunks, and changes to
+/// them through the server's own block updates.
+interface %world {
+    record block-change {
+        x: s32,
+        y: s32,
+        z: s32,
+        /// `minecraft:oak_log[axis=y]`; properties left out take the block's
+        /// defaults, `minecraft:stone` alone is the default state.
+        state: string,
+    }
+    /// The block state at a position in a dimension (`minecraft:overworld`,
+    /// ...), as `minecraft:oak_log[axis=y]`, as of this call: none where the
+    /// server has no chunk loaded there.
+    get-block: func(dimension: string, x: s32, y: s32, z: s32) -> option<string>;
+    /// The biome at a position (`minecraft:plains`, ...), as the server
+    /// stores it (one per 4 x 4 x 4 cell): none where no chunk is loaded.
+    get-biome: func(dimension: string, x: s32, y: s32, z: s32) -> option<string>;
+    /// Sets blocks as `/setblock` does: the old block entity removed,
+    /// neighbours and shapes updated, light, and every player told. Every
+    /// state is checked now (an error queues nothing); the changes are made
+    /// in order after this call returns, before that dimension's next tick;
+    /// one in a chunk not loaded then is skipped. At most 4096 per call.
+    set-blocks: func(dimension: string, blocks: list<block-change>) -> result<_, string>;
+}
+
 /// What the server calls in a server mod (manifest `api = "0.3"`,
 /// experimental). Only the hooks `init` asks for are ever called. The player
 /// in each event is as the server saw them when it happened.
 interface server-events {
     use players.{player};
 
+    record block-pos {
+        x: s32,
+        y: s32,
+        z: s32,
+    }
+    /// What an argument of a command takes. The server sends each command
+    /// and its arguments to players' games, whose chat box completes and
+    /// colours them as vanilla's; the server parses them before the mod's
+    /// `command` hook gets their values.
+    variant argument-kind {
+        /// One word: letters, digits and `_ - . +`.
+        word,
+        /// The rest of the line, spaces included: only last.
+        text,
+        /// A whole number, within the bounds given.
+        integer(tuple<option<s32>, option<s32>>),
+        /// A number with or without decimals.
+        number,
+        /// `true` or `false`.
+        boolean,
+        /// One online player: a name, or `@s` or `@p` (whoever typed it,
+        /// as vanilla picks for a player).
+        player,
+        /// A block position: three whole numbers, each one also `~` or
+        /// `~n`, relative to whoever typed it.
+        block-pos,
+    }
+    record argument {
+        /// Shown in the chat box's hint (`<height>`) and the key of its value.
+        name: string,
+        kind: argument-kind,
+        /// Optional arguments come after every required one.
+        optional: bool,
+    }
+    record server-command {
+        /// Without the slash. A name vanilla already uses is refused
+        /// (vanilla's command runs).
+        name: string,
+        /// In order; none: the command takes nothing after its name. Free
+        /// text is one optional `text` argument.
+        arguments: list<argument>,
+    }
+    /// An argument's value, parsed as its kind says.
+    variant argument-value {
+        word(string),
+        text(string),
+        integer(s32),
+        number(f64),
+        boolean(bool),
+        player(player),
+        block-pos(block-pos),
+    }
     record registration {
-        /// Commands players may type, without the slash. A name vanilla
-        /// already uses is refused (vanilla's command runs).
-        commands: list<string>,
+        /// Commands players may type.
+        commands: list<server-command>,
         /// Call `tick` every server tick (20 per second).
         tick: bool,
         /// Call `player-joined` and `player-left`.
@@ -491,11 +761,6 @@ interface server-events {
         /// Call `block-broken` and `block-placed`.
         blocks: bool,
     }
-    record block-pos {
-        x: s32,
-        y: s32,
-        z: s32,
-    }
     /// Once, after loading. An error keeps the mod off and is logged.
     init: func() -> result<registration, string>;
     /// Each server tick, with the server's tick counter.
@@ -507,8 +772,10 @@ interface server-events {
     /// A chat message a player sent, as plain text.
     chat: func(player: player, text: string);
     /// `/name args` typed by `player`: ok(some(text)) is their feedback,
-    /// err(text) their error in red.
-    command: func(player: player, name: string, args: string) -> result<option<string>, string>;
+    /// err(text) their error in red. `values` holds each argument given, by
+    /// name, in order (an optional one left out isn't there); a line that
+    /// doesn't parse never reaches the mod: the player gets vanilla's error.
+    command: func(player: player, name: string, args: string, values: list<tuple<string, argument-value>>) -> result<option<string>, string>;
     /// A player broke the block at `pos` in their dimension: `state` is what
     /// was there, as `minecraft:oak_log[axis=y]`.
     block-broken: func(player: player, pos: block-pos, state: string);
@@ -534,6 +801,7 @@ world horizon-server-mod {
     import log;
     import storage;
     import players;
+    import %world;
     export server-events;
 }
 
@@ -545,6 +813,8 @@ world horizon-ui-mod {
     import ui;
     import render;
     import input;
+    import recipes;
+    import browser;
     export ui-events;
 }
 
@@ -559,3 +829,9 @@ world render-host {
     import render;
     import input;
 }
+
+/// The game's side of capability `recipes` (imports only).
+world recipes-host {
+    import recipes;
+    import browser;
+}
diff --git a/crates/horizon-mods/src/api_level.rs b/crates/horizon-mods/src/api_level.rs
index bf87d0cfa..045a9346b 100644
--- a/crates/horizon-mods/src/api_level.rs
+++ b/crates/horizon-mods/src/api_level.rs
@@ -7,13 +7,13 @@
 //! version's level so the launcher can tell before it installs.
 
 /// The newest level this Horizon serves.
-pub const LEVEL: u32 = 3;
+pub const LEVEL: u32 = 7;
 
 /// Every function the game offers mods, as `interface.function`, with its
 /// level. Level 0 is the contract of Horizon 0.2.67 to 0.2.69. A new
 /// function takes the next level and raises [`LEVEL`] (the `api_reference`
 /// test fails until it is listed here).
-pub const FUNCTIONS: [(&str, u32); 34] = [
+pub const FUNCTIONS: [(&str, u32); 46] = [
     ("log.write", 0),
     ("game.get-player", 0),
     ("game.get-clock", 0),
@@ -48,6 +48,18 @@ pub const FUNCTIONS: [(&str, u32); 34] = [
     ("players.broadcast", 1),
     ("game.raycast", 2),
     ("command.run-quiet", 3),
+    ("world.get-block", 4),
+    ("world.get-biome", 4),
+    ("world.set-blocks", 4),
+    ("recipes.items", 5),
+    ("recipes.all", 5),
+    ("recipes.known", 5),
+    ("browser.set-items", 6),
+    ("browser.poll", 6),
+    ("browser.set-recipes", 6),
+    ("recipes.place", 6),
+    ("recipes.give", 6),
+    ("render.set-far-terrain", 7),
 ];
 
 /// What the game's program carries so the launcher can read its level
diff --git a/crates/horizon-mods/src/commands.rs b/crates/horizon-mods/src/commands.rs
new file mode 100644
index 000000000..4421b47ba
--- /dev/null
+++ b/crates/horizon-mods/src/commands.rs
@@ -0,0 +1,301 @@
+//! Server mods' typed commands: an argument line parsed as the command's
+//! arguments say, the way vanilla's Brigadier parsers read them, with
+//! vanilla's error messages. The game sends the same arguments to players'
+//! command trees, so their chat box checks them before the server does.
+use crate::runtime::{Argument, ArgumentKind, ArgumentValue, BlockPos, ServerPlayer};
+
+/// The values of `args`, typed by `player`, for `arguments` (in order;
+/// optional ones left out aren't there), or the error the player reads.
+pub fn parse(
+    arguments: &[Argument],
+    args: &str,
+    player: &ServerPlayer,
+    online: &[ServerPlayer],
+) -> Result<Vec<(String, ArgumentValue)>, String> {
+    let mut values = Vec::new();
+    let mut rest = args;
+    for (i, argument) in arguments.iter().enumerate() {
+        if i > 0 && !rest.is_empty() {
+            rest = rest.strip_prefix(' ').ok_or(
+                "Expected whitespace to end one argument, but found trailing data".to_string(),
+            )?;
+        }
+        if rest.is_empty() {
+            if argument.optional {
+                break;
+            }
+            return Err("Unknown or incomplete command, see below for error".into());
+        }
+        let (value, after) = one(&argument.kind, rest, player, online)?;
+        values.push((argument.name.clone(), value));
+        rest = after;
+    }
+    if !rest.is_empty() {
+        return Err("Incorrect argument for command".into());
+    }
+    Ok(values)
+}
+
+/// StringReader.isAllowedInUnquotedString.
+fn unquoted(c: char) -> bool {
+    c.is_ascii_alphanumeric() || matches!(c, '_' | '-' | '.' | '+')
+}
+
+/// The unquoted string at the start of `s`, and what follows it.
+fn word(s: &str) -> (&str, &str) {
+    let end = s.find(|c: char| !unquoted(c)).unwrap_or(s.len());
+    s.split_at(end)
+}
+
+/// One argument from the start of `s`, and what follows it.
+fn one<'a>(
+    kind: &ArgumentKind,
+    s: &'a str,
+    player: &ServerPlayer,
+    online: &[ServerPlayer],
+) -> Result<(ArgumentValue, &'a str), String> {
+    Ok(match kind {
+        ArgumentKind::Word => {
+            let (w, rest) = word(s);
+            if w.is_empty() {
+                return Err("Expected string".into());
+            }
+            (ArgumentValue::Word(w.into()), rest)
+        }
+        ArgumentKind::Text => (ArgumentValue::Text(s.into()), ""),
+        ArgumentKind::Integer((min, max)) => {
+            let (n, rest) = integer(s)?;
+            if let Some(min) = min.filter(|m| n < *m) {
+                return Err(format!("Integer must not be less than {min}, found {n}"));
+            }
+            if let Some(max) = max.filter(|m| n > *m) {
+                return Err(format!("Integer must not be more than {max}, found {n}"));
+            }
+            (ArgumentValue::Integer(n), rest)
+        }
+        ArgumentKind::Number => {
+            let (n, rest) = double(s)?;
+            (ArgumentValue::Number(n), rest)
+        }
+        ArgumentKind::Boolean => {
+            let (w, rest) = word(s);
+            let b = match w {
+                "true" => true,
+                "false" => false,
+                "" => return Err("Expected bool".into()),
+                _ => {
+                    return Err(format!(
+                        "Invalid boolean, expected 'true' or 'false' but found '{w}'"
+                    ));
+                }
+            };
+            (ArgumentValue::Boolean(b), rest)
+        }
+        ArgumentKind::Player => {
+            if let Some(selector) = s.strip_prefix('@') {
+                let (kind, rest) = word(selector);
+                return match kind {
+                    // A player's @p is themselves (the nearest to where they are).
+                    "s" | "p" => Ok((ArgumentValue::Player(player.clone()), rest)),
+                    "a" | "e" | "r" | "n" => {
+                        Err("Only one player is allowed, but the provided selector allows more than one".into())
+                    }
+                    _ => Err(format!("Unknown selector type '@{kind}'")),
+                };
+            }
+            let (name, rest) = word(s);
+            if name.is_empty() {
+                return Err("Invalid name or UUID".into());
+            }
+            let found = online
+                .iter()
+                .find(|p| p.name.eq_ignore_ascii_case(name))
+                .ok_or("No player was found")?;
+            (ArgumentValue::Player(found.clone()), rest)
+        }
+        ArgumentKind::BlockPos => {
+            let (x, rest) = coordinate(s, player.x)?;
+            let rest = rest
+                .strip_prefix(' ')
+                .ok_or("Incomplete (expected 3 coordinates)")?;
+            let (y, rest) = coordinate(rest, player.y)?;
+            let rest = rest
+                .strip_prefix(' ')
+                .ok_or("Incomplete (expected 3 coordinates)")?;
+            let (z, rest) = coordinate(rest, player.z)?;
+            (ArgumentValue::BlockPos(BlockPos { x, y, z }), rest)
+        }
+    })
+}
+
+/// StringReader.readInt.
+fn integer(s: &str) -> Result<(i32, &str), String> {
+    let end = s
+        .find(|c: char| !(c.is_ascii_digit() || c == '-' || c == '.'))
+        .unwrap_or(s.len());
+    let (n, rest) = s.split_at(end);
+    if n.is_empty() {
+        return Err("Expected integer".into());
+    }
+    let n = n.parse().map_err(|_| format!("Invalid integer '{n}'"))?;
+    Ok((n, rest))
+}
+
+/// StringReader.readDouble.
+fn double(s: &str) -> Result<(f64, &str), String> {
+    let end = s
+        .find(|c: char| !(c.is_ascii_digit() || c == '-' || c == '.'))
+        .unwrap_or(s.len());
+    let (n, rest) = s.split_at(end);
+    if n.is_empty() {
+        return Err("Expected double".into());
+    }
+    let n = n.parse().map_err(|_| format!("Invalid double '{n}'"))?;
+    Ok((n, rest))
+}
+
+/// WorldCoordinate.parseInt, then BlockPos.containing: `~` and `~n` from
+/// `base`, a whole number as it is.
+fn coordinate(s: &str, base: f64) -> Result<(i32, &str), String> {
+    if s.starts_with('^') {
+        return Err(
+            "Cannot mix world & local coordinates (everything must either use ^ or not)".into(),
+        );
+    }
+    if let Some(offset) = s.strip_prefix('~') {
+        if offset.is_empty() || offset.starts_with(' ') {
+            return Ok((base.floor() as i32, offset));
+        }
+        let (n, rest) = double(offset)?;
+        return Ok(((base + n).floor() as i32, rest));
+    }
+    integer(s)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::runtime::GameMode;
+
+    fn player(name: &str) -> ServerPlayer {
+        ServerPlayer {
+            id: format!("id-{name}"),
+            name: name.into(),
+            x: 10.7,
+            y: 64.0,
+            z: -3.2,
+            dimension: "minecraft:overworld".into(),
+            game_mode: GameMode::Survival,
+            health: 20.0,
+        }
+    }
+    fn arg(name: &str, kind: ArgumentKind, optional: bool) -> Argument {
+        Argument {
+            name: name.into(),
+            kind,
+            optional,
+        }
+    }
+
+    #[test]
+    fn values_in_order_and_optional_ones_left_out() {
+        let alex = player("Alex");
+        let online = [alex.clone(), player("Steve")];
+        let args = [
+            arg("who", ArgumentKind::Player, false),
+            arg("height", ArgumentKind::Integer((Some(1), Some(64))), true),
+            arg("note", ArgumentKind::Text, true),
+        ];
+        let v = parse(&args, "steve 5 hello there", &alex, &online).unwrap();
+        assert_eq!(v[0].0, "who");
+        assert!(matches!(&v[0].1, ArgumentValue::Player(p) if p.name == "Steve"));
+        assert_eq!(v[1], ("height".into(), ArgumentValue::Integer(5)));
+        assert_eq!(
+            v[2],
+            ("note".into(), ArgumentValue::Text("hello there".into()))
+        );
+        let v = parse(&args, "@s", &alex, &online).unwrap();
+        assert_eq!(v.len(), 1);
+        assert!(matches!(&v[0].1, ArgumentValue::Player(p) if p.name == "Alex"));
+    }
+
+    #[test]
+    fn vanilla_errors() {
+        let alex = player("Alex");
+        let online = [alex.clone()];
+        let height = [arg(
+            "height",
+            ArgumentKind::Integer((Some(1), Some(64))),
+            false,
+        )];
+        let err = |a: &[Argument], s| parse(a, s, &alex, &online).unwrap_err();
+        assert_eq!(
+            err(&height, "0"),
+            "Integer must not be less than 1, found 0"
+        );
+        assert_eq!(
+            err(&height, "65"),
+            "Integer must not be more than 64, found 65"
+        );
+        assert_eq!(err(&height, "x"), "Expected integer");
+        assert_eq!(err(&height, "1.5"), "Invalid integer '1.5'");
+        assert_eq!(
+            err(&height, ""),
+            "Unknown or incomplete command, see below for error"
+        );
+        assert_eq!(err(&height, "3 4"), "Incorrect argument for command");
+        let who = [arg("who", ArgumentKind::Player, false)];
+        assert_eq!(err(&who, "Herobrine"), "No player was found");
+        assert_eq!(err(&who, "@q"), "Unknown selector type '@q'");
+        let flag = [arg("on", ArgumentKind::Boolean, false)];
+        assert_eq!(
+            err(&flag, "yes"),
+            "Invalid boolean, expected 'true' or 'false' but found 'yes'"
+        );
+        let pos = [arg("at", ArgumentKind::BlockPos, false)];
+        assert_eq!(err(&pos, "1 2"), "Incomplete (expected 3 coordinates)");
+    }
+
+    #[test]
+    fn block_positions_relative_to_the_player() {
+        let alex = player("Alex");
+        let pos = [arg("at", ArgumentKind::BlockPos, false)];
+        let v = parse(&pos, "~ ~1 ~-0.5", &alex, &[]).unwrap();
+        assert_eq!(
+            v[0].1,
+            ArgumentValue::BlockPos(BlockPos {
+                x: 10,
+                y: 65,
+                z: -4
+            })
+        );
+        let v = parse(&pos, "-5 70 ~", &alex, &[]).unwrap();
+        assert_eq!(
+            v[0].1,
+            ArgumentValue::BlockPos(BlockPos {
+                x: -5,
+                y: 70,
+                z: -4
+            })
+        );
+    }
+
+    #[test]
+    fn free_text_is_an_optional_text_argument() {
+        let alex = player("Alex");
+        let free = [arg("args", ArgumentKind::Text, true)];
+        assert_eq!(parse(&free, "", &alex, &[]), Ok(Vec::new()));
+        assert_eq!(
+            parse(&free, "anything at all", &alex, &[]),
+            Ok(vec![(
+                "args".into(),
+                ArgumentValue::Text("anything at all".into())
+            )])
+        );
+        assert_eq!(
+            parse(&[], "more", &alex, &[]),
+            Err("Incorrect argument for command".into())
+        );
+        assert_eq!(parse(&[], "", &alex, &[]), Ok(Vec::new()));
+    }
+}
diff --git a/crates/horizon-mods/src/lib.rs b/crates/horizon-mods/src/lib.rs
index 20f475165..983df73d4 100644
--- a/crates/horizon-mods/src/lib.rs
+++ b/crates/horizon-mods/src/lib.rs
@@ -6,6 +6,8 @@
 //! Nothing here runs unless a mod is installed and turned on: an empty
 //! [`Mods`] makes no engine and every hook returns at once.
 pub mod api_level;
+#[cfg(feature = "runtime")]
+pub mod commands;
 pub mod content;
 #[cfg(feature = "index")]
 pub mod index;
diff --git a/crates/horizon-mods/src/manifest.rs b/crates/horizon-mods/src/manifest.rs
index 5ad7823aa..c2f2f61fc 100644
--- a/crates/horizon-mods/src/manifest.rs
+++ b/crates/horizon-mods/src/manifest.rs
@@ -97,9 +97,15 @@ pub enum Capability {
     Input,
     /// The players on the server and messages to them (server mods).
     Players,
+    /// Blocks in the server's loaded chunks, and changes to them (server
+    /// mods; client mods later, where the game runs the world).
+    World,
+    /// The recipes and items the game knows, for recipe viewers
+    /// (interface `recipes`).
+    Recipes,
 }
 impl Capability {
-    pub const ALL: [Capability; 10] = [
+    pub const ALL: [Capability; 12] = [
         Capability::GameRead,
         Capability::Chat,
         Capability::Hud,
@@ -110,10 +116,15 @@ impl Capability {
         Capability::Render,
         Capability::Input,
         Capability::Players,
+        Capability::World,
+        Capability::Recipes,
     ];
     /// Whether a server mod may have it: the others act on a local player.
     pub fn on_server(self) -> bool {
-        matches!(self, Capability::Storage | Capability::Players)
+        matches!(
+            self,
+            Capability::Storage | Capability::Players | Capability::World
+        )
     }
     /// The WIT interface it grants, in `horizon:mods`.
     pub fn interface(self) -> &'static str {
@@ -128,6 +139,8 @@ impl Capability {
             Capability::Render => "render",
             Capability::Input => "input",
             Capability::Players => "players",
+            Capability::World => "world",
+            Capability::Recipes => "recipes",
         }
     }
     /// May change in any release: a mod uses it only with
@@ -135,7 +148,7 @@ impl Capability {
     pub fn is_experimental(self) -> bool {
         matches!(
             self,
-            Capability::Ui | Capability::Render | Capability::Input
+            Capability::Ui | Capability::Render | Capability::Input | Capability::Recipes
         )
     }
     /// What the player reads before turning the mod on: "May <this>".
@@ -153,6 +166,10 @@ impl Capability {
                 "see the keys you hold and your clicks, take over the use button on its own items and the mouse wheel, and add keys"
             }
             Capability::Players => "see who is on the server and message them",
+            Capability::World => "read and change the world's blocks",
+            Capability::Recipes => {
+                "read the game's recipes and items and which recipes you know, place recipes in your crafting grid and, in creative mode, give you items"
+            }
         }
     }
     /// The capability a component import needs, `Ok(None)` for one every
@@ -167,6 +184,10 @@ impl Capability {
         if interface == "log" {
             return Ok(None);
         }
+        // A recipe viewer's panel is part of capability `ui`.
+        if interface == "browser" {
+            return Ok(Some(Capability::Ui));
+        }
         Capability::ALL
             .into_iter()
             .filter(|c| *c != Capability::Registries)
@@ -188,6 +209,8 @@ impl fmt::Display for Capability {
             Capability::Render => "render",
             Capability::Input => "input",
             Capability::Players => "players",
+            Capability::World => "world",
+            Capability::Recipes => "recipes",
         };
         f.write_str(name)
     }
diff --git a/crates/horizon-mods/src/runtime.rs b/crates/horizon-mods/src/runtime.rs
index ce48f2317..cff44722b 100644
--- a/crates/horizon-mods/src/runtime.rs
+++ b/crates/horizon-mods/src/runtime.rs
@@ -1,12 +1,13 @@
 //! Loading and calling mods with wasmtime's component model.
 use crate::manifest::{Manifest, Package, Side};
 use server_bindings::{
-    HorizonServerMod, exports::horizon::mods::server_events::Registration as ServerRegistration,
-    horizon::mods::players,
+    HorizonServerMod,
+    exports::horizon::mods::server_events::Registration as ServerRegistration,
+    horizon::mods::{players, world as mod_world},
 };
 use std::{
     path::{Path, PathBuf},
-    sync::Arc,
+    sync::{Arc, Mutex},
     time::{Duration, Instant, SystemTime},
 };
 use wasmtime::{
@@ -25,6 +26,7 @@ mod server_bindings {
     wasmtime::component::bindgen!({
         path: "../horizon-mod-sdk/wit",
         world: "horizon-server-mod",
+        additional_derives: [PartialEq],
         with: {
             "horizon:mods/log": super::bindings::horizon::mods::log,
             "horizon:mods/storage": super::bindings::horizon::mods::storage,
@@ -50,8 +52,11 @@ use bindings::{
     horizon::mods::{chat, command, game, hud, log as mod_log, storage},
 };
 pub use server_bindings::{
-    exports::horizon::mods::server_events::BlockPos,
+    exports::horizon::mods::server_events::{
+        Argument, ArgumentKind, ArgumentValue, BlockPos, ServerCommand,
+    },
     horizon::mods::players::{GameMode, Player as ServerPlayer},
+    horizon::mods::world::BlockChange,
 };
 type ClientEvents = bindings::exports::horizon::mods::events::Guest;
 type ServerEvents = server_bindings::exports::horizon::mods::server_events::Guest;
@@ -73,11 +78,29 @@ use render_bindings::horizon::mods::input;
 pub use render_bindings::horizon::mods::input::{Event as InputEvent, HeldItem, ItemUse};
 /// What capability `render` asks the game to draw (WIT `interface render`).
 pub use render_bindings::horizon::mods::render::{
-    Corner as RenderCorner, FillShape, FrameRate, ItemShape, Minimap as ModMinimap,
-    Point as RenderPoint, QuadShape, Rect as RenderRect, Shape, SpriteShape, TextShape,
-    Zoom as ModZoom,
+    Corner as RenderCorner, FarTerrain as ModFarTerrain, FillShape, FrameRate, ItemShape,
+    Minimap as ModMinimap, Point as RenderPoint, QuadShape, Rect as RenderRect, Shape, SpriteShape,
+    TextShape, Zoom as ModZoom,
 };
 use render_bindings::{RenderHost, horizon::mods::render};
+/// Capability `recipes`'s imports (docs/mods.md): the game's recipes and items.
+mod recipes_bindings {
+    wasmtime::component::bindgen!({
+        path: "../horizon-mod-sdk/wit",
+        world: "recipes-host",
+    });
+}
+/// Capability `ui`'s recipe viewer panel (WIT `interface browser`).
+pub use recipes_bindings::horizon::mods::browser::{
+    Click as BrowserClick, Event as BrowserEvent, ItemKey as BrowserItemKey,
+    Layout as BrowserLayout, RecipeView as BrowserRecipe, SlotClick as BrowserSlotClick,
+    Stack as BrowserStack,
+};
+/// What capability `recipes` reads (WIT `interface recipes`).
+pub use recipes_bindings::horizon::mods::recipes::{
+    Item as RecipeItem, Kind as RecipeKind, Recipe, Stack as RecipeStack,
+};
+use recipes_bindings::{RecipesHost, horizon::mods::browser, horizon::mods::recipes};
 
 /// A mod's linear memory cap.
 const MEMORY: usize = 64 << 20;
@@ -87,6 +110,8 @@ const FUEL_INIT: u64 = 2_000_000_000;
 const FUEL_TICK: u64 = 50_000_000;
 const FUEL_FRAME: u64 = 10_000_000;
 const FUEL_EVENT: u64 = 100_000_000;
+/// Blocks a mod may set per `world.set-blocks` call.
+pub const BLOCKS_PER_CALL: usize = 4096;
 /// Chat lines a mod may show per call, HUD lines and their length.
 const CHAT_PER_CALL: usize = 8;
 /// `command.run-quiet` lines one call of a mod may queue (a quiet payload's
@@ -133,6 +158,23 @@ pub struct Snapshot {
     /// its distance from the eye, for `game.raycast`; the game works it out
     /// only while a mod calls it ([`Mods::wants_raycast`]).
     pub view_hit: Option<(f32, Hit)>,
+    /// Every item and recipe, for capability `recipes`; the game makes them
+    /// once, and only while a mod reads them ([`Mods::wants_recipes`]).
+    pub recipes: Option<Arc<Recipes>>,
+    /// The `book-id`s of the recipes the player's book holds.
+    pub known_recipes: Arc<[i32]>,
+    /// The open screen takes recipes (`recipes.place`).
+    pub placing: bool,
+    /// The player is in creative mode (`recipes.give`).
+    pub creative: bool,
+}
+
+/// Capability `recipes`'s tables: `items` in the registry's order, which
+/// each [`RecipeStack::item`] indexes.
+#[derive(Clone, Debug, Default)]
+pub struct Recipes {
+    pub items: Vec<RecipeItem>,
+    pub recipes: Vec<Recipe>,
 }
 
 /// Which mods a game starts: the window's game the client mods, the game
@@ -182,6 +224,13 @@ pub enum Output {
         text: String,
         error: bool,
     },
+    /// `world.set-blocks`: changes to make in `dimension`, in order, each
+    /// state checked by the [`WorldView`] lent for the call.
+    SetBlocks {
+        name: String,
+        dimension: String,
+        blocks: Vec<BlockChange>,
+    },
     /// `ui.open-screen`: the mod's entry in `entries()`; what it shows is
     /// [`Mods::screen`].
     OpenScreen { owner: usize },
@@ -189,8 +238,34 @@ pub enum Output {
     CloseScreen { owner: usize },
     /// `render.shake`: strength 0 to 1, fading out over `seconds` (≤ 10).
     Shake { strength: f32, seconds: f32 },
+    /// `recipes.place`: the recipe book's click on this display id, all of
+    /// it when `all`.
+    PlaceRecipe { book_id: i32, all: bool },
+    /// `recipes.give`: a stack for a creative player.
+    Give {
+        item: String,
+        count: u32,
+        components: String,
+    },
 }
 
+/// The game's world as capability `world` reads it during a call: the
+/// game lends one with [`Mods::lend_world`] and takes it back after.
+pub trait WorldView: std::any::Any + Send {
+    /// The block state at a position, `minecraft:oak_log[axis=y]`; `None`
+    /// where no chunk of that dimension is loaded.
+    fn block(&self, dimension: &str, x: i32, y: i32, z: i32) -> Option<String>;
+    /// The biome at a position, `minecraft:plains`; `None` as for blocks.
+    fn biome(&self, dimension: &str, x: i32, y: i32, z: i32) -> Option<String>;
+    /// Whether `dimension` is one the server has.
+    fn has_dimension(&self, dimension: &str) -> bool;
+    /// `Err` (why) for a state string that names no block state.
+    fn check_state(&self, state: &str) -> Result<(), String>;
+}
+
+/// The view lent for the current calls, shared by every mod's store.
+type WorldSlot = Arc<Mutex<Option<Box<dyn WorldView>>>>;
+
 /// A mod's text panel, drawn every frame until it changes.
 #[derive(Clone, Debug)]
 pub struct Panel {
@@ -241,6 +316,8 @@ struct Running {
     hooks: Hooks,
     /// It imports `game.raycast`.
     raycasts: bool,
+    /// It imports capability `recipes`.
+    reads_recipes: bool,
 }
 
 /// A running mod's exports and the hooks its `init` asked for.
@@ -261,10 +338,10 @@ impl Hooks {
             Hooks::Client(..) => None,
         }
     }
-    fn commands(&self) -> &[String] {
+    fn commands(&self) -> Vec<&str> {
         match self {
-            Hooks::Client(_, r) => &r.commands,
-            Hooks::Server(_, r) => &r.commands,
+            Hooks::Client(_, r) => r.commands.iter().map(String::as_str).collect(),
+            Hooks::Server(_, r) => r.commands.iter().map(|c| c.name.as_str()).collect(),
         }
     }
 }
@@ -282,6 +359,46 @@ struct UiState {
     close: bool,
 }
 
+/// Capability `ui`'s panel beside container screens (`browser`).
+#[derive(Default)]
+struct BrowserState {
+    items: Vec<BrowserStack>,
+    /// Which `set-items` or `set-recipes` call the panel is from, unique
+    /// across mods and reloads, so the game converts them once.
+    version: u64,
+    /// `set-recipes`' title and recipes, shown instead of the items.
+    recipes: Option<RecipePage>,
+    events: std::collections::VecDeque<BrowserEvent>,
+}
+/// What `browser.set-recipes` shows: a title, tabs (`tab` the selected
+/// one) and the recipes.
+#[derive(Clone, Debug)]
+pub struct RecipePage {
+    pub title: String,
+    pub tabs: Vec<BrowserStack>,
+    pub tab: u32,
+    pub recipes: Vec<BrowserRecipe>,
+}
+static BROWSER_VERSION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
+/// Items a panel may hold, and events kept for `browser.poll`.
+const BROWSER_ITEMS: usize = 8192;
+/// `recipes.place` and `give` calls a hook call may make.
+const RECIPE_ACTIONS: usize = 36;
+/// Recipes `set-recipes` may show, slots in one, and stacks a slot cycles.
+const BROWSER_RECIPES: usize = 256;
+const RECIPE_SLOTS: usize = 9;
+const RECIPE_TABS: usize = 16;
+const SLOT_STACKS: usize = 64;
+const BROWSER_EVENTS: usize = 256;
+impl BrowserState {
+    fn push(&mut self, event: BrowserEvent) {
+        if self.events.len() == BROWSER_EVENTS {
+            self.events.pop_front();
+        }
+        self.events.push_back(event);
+    }
+}
+
 struct State {
     name: String,
     id: String,
@@ -297,7 +414,10 @@ struct State {
     zoom: Option<ModZoom>,
     /// Capability `render`'s minimap, when the mod shows one.
     minimap: Option<ModMinimap>,
+    /// Capability `render`'s far terrain, when the mod draws one.
+    far_terrain: Option<ModFarTerrain>,
     input: InputState,
+    browser: BrowserState,
     /// Capability `storage`'s folder; made on first `set`.
     data_dir: PathBuf,
     /// Bytes `storage::set` may still write before this hook call ends
@@ -306,6 +426,7 @@ struct State {
     /// needs its own budget.
     storage_budget: u64,
     limits: StoreLimits,
+    world: WorldSlot,
 }
 
 /// The installed mods and the engine running them. `Mods::default()` is
@@ -316,9 +437,40 @@ pub struct Mods {
     entries: Vec<Entry>,
     snapshot: Arc<Snapshot>,
     out: Vec<Output>,
+    world: WorldSlot,
+    /// Moves on whenever a mod starts or stops: the game resends the server
+    /// mods' commands to players when it changes.
+    generation: u64,
 }
 
 impl Mods {
+    /// Changes whenever the running mods (so their commands) change.
+    pub fn generation(&self) -> u64 {
+        self.generation
+    }
+    /// Whether a running mod may use capability `world`: only then is a
+    /// view worth lending.
+    pub fn wants_world(&self) -> bool {
+        self.entries.iter().any(|e| {
+            e.status == Status::Running
+                && e.manifest
+                    .as_ref()
+                    .is_some_and(|m| m.capabilities.contains(&crate::Capability::World))
+        })
+    }
+    /// Lends the game's world to capability `world` for the calls until
+    /// [`Mods::take_world`]; with none lent, `get-block` finds nothing and
+    /// `set-blocks` checks only its count.
+    pub fn lend_world(&mut self, view: Box<dyn WorldView>) {
+        if let Ok(mut slot) = self.world.lock() {
+            *slot = Some(view);
+        }
+    }
+    /// The view [`Mods::lend_world`] lent, back to the game.
+    pub fn take_world(&mut self) -> Option<Box<dyn WorldView>> {
+        self.world.lock().ok()?.take()
+    }
+
     /// Reads every mod at `paths` and starts those `enabled` says are on,
     /// client and server mods alike. A command that `reserved` (vanilla's
     /// commands) or an earlier mod already uses is refused.
@@ -388,10 +540,14 @@ impl Mods {
                 .map_err(|e| e.to_string())?;
             players::add_to_linker::<State, HasSelf<State>>(&mut linker, |s| s)
                 .map_err(|e| e.to_string())?;
+            mod_world::add_to_linker::<State, HasSelf<State>>(&mut linker, |s| s)
+                .map_err(|e| e.to_string())?;
             UiHost::add_to_linker::<State, HasSelf<State>>(&mut linker, |s| s)
                 .map_err(|e| e.to_string())?;
             RenderHost::add_to_linker::<State, HasSelf<State>>(&mut linker, |s| s)
                 .map_err(|e| e.to_string())?;
+            RecipesHost::add_to_linker::<State, HasSelf<State>>(&mut linker, |s| s)
+                .map_err(|e| e.to_string())?;
             self.engine = Some((engine, linker));
         }
         Ok(self.engine.as_ref().expect("made above"))
@@ -426,9 +582,11 @@ impl Mods {
             .iter()
             .filter_map(|e| e.run.as_ref())
             .filter(|r| r.hooks.server().is_some() == server)
-            .flat_map(|r| r.hooks.commands().iter().cloned())
+            .flat_map(|r| r.hooks.commands())
+            .map(str::to_owned)
             .collect();
         let snapshot = self.snapshot.clone();
+        let world = self.world.clone();
         let (engine, linker) = self.engine()?;
         let component =
             Component::new(engine, wasm).map_err(|e| format!("not a component: {e}"))?;
@@ -460,13 +618,16 @@ impl Mods {
             corner: None,
             zoom: None,
             minimap: None,
+            far_terrain: None,
             input: InputState::default(),
+            browser: BrowserState::default(),
             data_dir,
             storage_budget: STORAGE_WRITE_BUDGET,
             limits: StoreLimitsBuilder::new()
                 .memory_size(MEMORY)
                 .instances(16)
                 .build(),
+            world,
         };
         let mut store = Store::new(engine, state);
         store.limiter(|s| &mut s.limits);
@@ -492,23 +653,37 @@ impl Mods {
                 .map_err(|e| reason(&e))??;
             (Hooks::Client(exports, r), ui)
         };
-        let commands = match &mut hooks {
-            Hooks::Client(_, r) => &mut r.commands,
-            Hooks::Server(_, r) => &mut r.commands,
-        };
-        commands.retain(|c| {
-            let free = !reserved(c) && !taken.contains(c);
+        let free = |c: &str| {
+            let free = !reserved(c) && !taken.iter().any(|t| t == c);
             if !free {
                 log::warn!("Horizon: mod {} cannot take /{c}: already a command", m.id);
             }
             free
-        });
+        };
+        match &mut hooks {
+            Hooks::Client(_, r) => r.commands.retain(|c| free(c)),
+            Hooks::Server(_, r) => {
+                r.commands.retain(|c| free(&c.name));
+                for c in &mut r.commands {
+                    if let Err(e) = check_arguments(&c.arguments) {
+                        log::warn!(
+                            "Horizon: mod {}'s /{}: {e}; it takes free text",
+                            m.id,
+                            c.name
+                        );
+                        c.arguments.clear();
+                    }
+                }
+            }
+        }
+        self.generation += 1;
         self.out.append(&mut store.data_mut().out);
         Ok(Some(Running {
             store,
             ui,
             hooks,
             raycasts: functions.iter().any(|f| f == "game.raycast"),
+            reads_recipes: functions.iter().any(|f| f.starts_with("recipes.")),
         }))
     }
 
@@ -619,6 +794,7 @@ impl Mods {
                 });
                 entry.status = Status::Failed(reason);
                 entry.run = None;
+                self.generation += 1;
                 None
             }
         }
@@ -643,7 +819,7 @@ impl Mods {
     fn command_owner(&self, server: bool, name: &str) -> Option<usize> {
         self.entries.iter().position(|e| {
             e.run.as_ref().is_some_and(|r| {
-                r.hooks.server().is_some() == server && r.hooks.commands().iter().any(|c| c == name)
+                r.hooks.server().is_some() == server && r.hooks.commands().contains(&name)
             })
         })
     }
@@ -676,7 +852,7 @@ impl Mods {
             .iter()
             .filter_map(|e| e.run.as_ref())
             .filter(move |r| r.hooks.server().is_some() == server)
-            .flat_map(|r| r.hooks.commands().iter().map(String::as_str))
+            .flat_map(|r| r.hooks.commands())
     }
 
     /// A server tick.
@@ -719,9 +895,13 @@ impl Mods {
             |m, s| m.call_block_placed(s, player, pos, state),
         );
     }
-    /// The commands running server mods own, for the server's command tree.
-    pub fn server_commands(&self) -> impl Iterator<Item = &str> {
-        self.owned_commands(true)
+    /// The commands running server mods own and their arguments, for the
+    /// server's command tree.
+    pub fn server_commands(&self) -> impl Iterator<Item = &ServerCommand> {
+        self.entries
+            .iter()
+            .filter_map(|e| e.run.as_ref()?.hooks.server())
+            .flat_map(|r| r.commands.iter())
     }
     /// Runs `line` (without its slash), typed by `player`, if a server mod
     /// owns its command; its feedback is an [`Output::Reply`]. False when
@@ -731,18 +911,35 @@ impl Mods {
         let Some(i) = self.command_owner(true, name) else {
             return false;
         };
-        let result = self.call(i, FUEL_EVENT, |run| match &run.hooks {
-            Hooks::Server(m, _) => {
-                m.horizon_mods_server_events()
-                    .call_command(&mut run.store, player, name, args)
-            }
-            Hooks::Client(..) => Ok(Ok(None)),
-        });
         let reply = |text, error| Output::Reply {
             player: player.id.clone(),
             text,
             error,
         };
+        let arguments = self.entries[i]
+            .run
+            .as_ref()
+            .and_then(|r| r.hooks.server())
+            .and_then(|r| r.commands.iter().find(|c| c.name == name))
+            .map(|c| c.arguments.as_slice())
+            .unwrap_or_default();
+        let values = match crate::commands::parse(arguments, args, player, &self.snapshot.players) {
+            Ok(values) => values,
+            Err(e) => {
+                self.out.push(reply(e, true));
+                return true;
+            }
+        };
+        let result = self.call(i, FUEL_EVENT, |run| match &run.hooks {
+            Hooks::Server(m, _) => m.horizon_mods_server_events().call_command(
+                &mut run.store,
+                player,
+                name,
+                args,
+                &values,
+            ),
+            Hooks::Client(..) => Ok(Ok(None)),
+        });
         match result {
             Some(Ok(Some(text))) => self.out.push(reply(text, false)),
             Some(Err(text)) => self.out.push(reply(text, true)),
@@ -769,6 +966,58 @@ impl Mods {
             .iter()
             .any(|e| e.run.as_ref().is_some_and(|r| r.raycasts))
     }
+    /// The panel beside container screens (`browser.set-items`): the first
+    /// running mod with items or recipes, its index, the panel's version and
+    /// the items.
+    pub fn browser_items(&self) -> Option<(usize, u64, &[BrowserStack])> {
+        self.entries.iter().enumerate().find_map(|(i, e)| {
+            let b = &e.run.as_ref()?.store.data().browser;
+            (!b.items.is_empty() || b.recipes.is_some()).then_some((
+                i,
+                b.version,
+                b.items.as_slice(),
+            ))
+        })
+    }
+    /// What mod `owner`'s panel shows instead of its items
+    /// (`browser.set-recipes`).
+    pub fn browser_recipes(&self, owner: usize) -> Option<&RecipePage> {
+        let b = &self.entries.get(owner)?.run.as_ref()?.store.data().browser;
+        b.recipes.as_ref()
+    }
+    /// The player did `event` on mod `owner`'s panel.
+    pub fn browser_event(&mut self, owner: usize, event: BrowserEvent) {
+        if let Some(run) = self.entries.get_mut(owner).and_then(|e| e.run.as_mut()) {
+            run.store.data_mut().browser.push(event);
+        }
+    }
+    /// The key `key` went down with the pointer on `stack` in a container
+    /// screen: each mod with a key on it hears its own name for it.
+    pub fn browser_key(&mut self, key: &str, stack: &BrowserStack) {
+        for run in self.entries.iter_mut().filter_map(|e| e.run.as_mut()) {
+            let data = run.store.data_mut();
+            let names: Vec<String> = data
+                .input
+                .keys
+                .iter()
+                .filter(|k| k.key == key)
+                .map(|k| k.name.clone())
+                .collect();
+            for key in names {
+                data.browser.push(BrowserEvent::Key(BrowserItemKey {
+                    key,
+                    stack: stack.clone(),
+                }));
+            }
+        }
+    }
+    /// Some running mod reads capability `recipes`: the snapshot needs
+    /// [`Snapshot::recipes`] and [`Snapshot::known_recipes`].
+    pub fn wants_recipes(&self) -> bool {
+        self.entries
+            .iter()
+            .any(|e| e.run.as_ref().is_some_and(|r| r.reads_recipes))
+    }
     /// Some running mod has a `frame` hook: the game refreshes the snapshot
     /// every frame for it.
     pub fn wants_frames(&self) -> bool {
@@ -924,6 +1173,12 @@ impl Mods {
             .iter()
             .find_map(|e| e.run.as_ref()?.store.data().minimap)
     }
+    /// The far terrain the first running mod draws (capability `render`).
+    pub fn far_terrain(&self) -> Option<ModFarTerrain> {
+        self.entries
+            .iter()
+            .find_map(|e| e.run.as_ref()?.store.data().far_terrain)
+    }
     fn inputs(&self) -> impl Iterator<Item = &InputState> {
         self.entries
             .iter()
@@ -1016,6 +1271,7 @@ impl Mods {
                 continue;
             }
             any = true;
+            self.generation += 1;
             self.entries[i].modified = now;
             self.entries[i].run = None;
             let path = self.entries[i].path.clone();
@@ -1041,6 +1297,34 @@ impl Mods {
     }
 }
 
+/// A command's arguments are well formed: names given and distinct,
+/// optional ones last, free text only last.
+fn check_arguments(arguments: &[Argument]) -> Result<(), String> {
+    for (i, a) in arguments.iter().enumerate() {
+        if a.name.is_empty()
+            || !a
+                .name
+                .chars()
+                .all(|c| c.is_ascii_alphanumeric() || c == '_')
+        {
+            return Err(format!("argument name '{}' isn't [A-Za-z0-9_]+", a.name));
+        }
+        if arguments[..i].iter().any(|b| b.name == a.name) {
+            return Err(format!("two arguments are named {}", a.name));
+        }
+        if i > 0 && arguments[i - 1].optional && !a.optional {
+            return Err(format!("{} is required after an optional argument", a.name));
+        }
+        if a.kind == ArgumentKind::Text && i + 1 < arguments.len() {
+            return Err(format!(
+                "{} takes the rest of the line, so it must be last",
+                a.name
+            ));
+        }
+    }
+    Ok(())
+}
+
 fn modified(path: &Path) -> Option<SystemTime> {
     let meta = std::fs::metadata(path).ok()?;
     if meta.is_dir() {
@@ -1064,7 +1348,10 @@ fn reason(e: &wasmtime::Error) -> String {
 }
 
 fn clip(text: String) -> String {
-    match text.char_indices().nth(LINE_CHARS) {
+    clip_to(text, LINE_CHARS)
+}
+fn clip_to(text: String, chars: usize) -> String {
+    match text.char_indices().nth(chars) {
         Some((at, _)) => text[..at].to_string(),
         None => text,
     }
@@ -1125,6 +1412,125 @@ impl game::Host for State {
         (*at <= distance.min(RAYCAST_MAX) && !distance.is_nan()).then(|| hit.clone())
     }
 }
+impl browser::Host for State {
+    fn set_items(&mut self, items: Vec<BrowserStack>) {
+        self.browser.items = items
+            .into_iter()
+            .take(BROWSER_ITEMS)
+            .map(|s| BrowserStack {
+                item: clip(s.item),
+                components: clip_to(s.components, 4096),
+                ..s
+            })
+            .collect();
+        self.browser.version = BROWSER_VERSION.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    }
+    fn set_recipes(
+        &mut self,
+        title: String,
+        tabs: Vec<BrowserStack>,
+        tab: u32,
+        recipes: Vec<BrowserRecipe>,
+    ) {
+        let stack = |s: BrowserStack| BrowserStack {
+            item: clip(s.item),
+            components: clip_to(s.components, 4096),
+            ..s
+        };
+        let cycle = |list: Vec<BrowserStack>| -> Vec<BrowserStack> {
+            list.into_iter().take(SLOT_STACKS).map(stack).collect()
+        };
+        self.browser.recipes = (!recipes.is_empty()).then(|| {
+            let recipes = recipes
+                .into_iter()
+                .take(BROWSER_RECIPES)
+                .map(|r| BrowserRecipe {
+                    width: r.width.clamp(1, 3),
+                    height: r.height.clamp(1, 3),
+                    slots: r.slots.into_iter().take(RECIPE_SLOTS).map(cycle).collect(),
+                    results: cycle(r.results),
+                    note: clip(r.note),
+                    ..r
+                })
+                .collect();
+            RecipePage {
+                title: clip(title),
+                tabs: tabs.into_iter().take(RECIPE_TABS).map(stack).collect(),
+                tab,
+                recipes,
+            }
+        });
+        self.browser.version = BROWSER_VERSION.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+    }
+    fn poll(&mut self) -> Vec<BrowserEvent> {
+        self.browser.events.drain(..).collect()
+    }
+}
+impl recipes::Host for State {
+    fn items(&mut self) -> Vec<RecipeItem> {
+        self.snapshot
+            .recipes
+            .as_ref()
+            .map_or_else(Vec::new, |r| r.items.clone())
+    }
+    fn all(&mut self) -> Vec<Recipe> {
+        self.snapshot
+            .recipes
+            .as_ref()
+            .map_or_else(Vec::new, |r| r.recipes.clone())
+    }
+    fn known(&mut self) -> Vec<i32> {
+        self.snapshot.known_recipes.to_vec()
+    }
+    fn place(&mut self, book_id: i32, all: bool) -> Result<(), String> {
+        self.recipe_action()?;
+        if !self.snapshot.placing {
+            return Err("no screen that takes recipes is open".into());
+        }
+        if !self.snapshot.known_recipes.contains(&book_id) {
+            return Err(format!(
+                "recipe {book_id} is not in the player's recipe book"
+            ));
+        }
+        self.out.push(Output::PlaceRecipe { book_id, all });
+        Ok(())
+    }
+    fn give(&mut self, stack: RecipeStack) -> Result<(), String> {
+        self.recipe_action()?;
+        if !self.snapshot.creative {
+            return Err("only in creative mode".into());
+        }
+        let item = self
+            .snapshot
+            .recipes
+            .as_ref()
+            .and_then(|r| r.items.get(stack.item as usize))
+            .ok_or_else(|| format!("no item {}", stack.item))?
+            .id
+            .clone();
+        self.out.push(Output::Give {
+            item,
+            count: stack.count.clamp(1, 99),
+            components: clip_to(stack.components, 4096),
+        });
+        Ok(())
+    }
+}
+impl State {
+    /// `recipes.place` and `give` take at most [`RECIPE_ACTIONS`] a call.
+    fn recipe_action(&self) -> Result<(), String> {
+        let done = self
+            .out
+            .iter()
+            .filter(|o| matches!(o, Output::PlaceRecipe { .. } | Output::Give { .. }))
+            .count();
+        if done < RECIPE_ACTIONS {
+            Ok(())
+        } else {
+            Err(format!("at most {RECIPE_ACTIONS} places and gives a call"))
+        }
+    }
+}
 impl State {
     /// Queues a chat line unless the call already sent [`CHAT_PER_CALL`].
     fn say(&mut self, line: impl FnOnce(String) -> Output) -> bool {
@@ -1153,6 +1559,40 @@ impl chat::Host for State {
         });
     }
 }
+impl mod_world::Host for State {
+    fn get_block(&mut self, dimension: String, x: i32, y: i32, z: i32) -> Option<String> {
+        let view = self.world.lock().ok()?;
+        view.as_ref()?.block(&dimension, x, y, z)
+    }
+    fn get_biome(&mut self, dimension: String, x: i32, y: i32, z: i32) -> Option<String> {
+        let view = self.world.lock().ok()?;
+        view.as_ref()?.biome(&dimension, x, y, z)
+    }
+    fn set_blocks(&mut self, dimension: String, blocks: Vec<BlockChange>) -> Result<(), String> {
+        if blocks.len() > BLOCKS_PER_CALL {
+            return Err(format!(
+                "{} blocks: at most {BLOCKS_PER_CALL} per call",
+                blocks.len()
+            ));
+        }
+        if let Some(view) = self.world.lock().ok().as_ref().and_then(|v| v.as_ref()) {
+            if !view.has_dimension(&dimension) {
+                return Err(format!("no dimension {dimension}"));
+            }
+            for b in &blocks {
+                view.check_state(&b.state)?;
+            }
+        }
+        if !blocks.is_empty() {
+            self.out.push(Output::SetBlocks {
+                name: self.name.clone(),
+                dimension,
+                blocks,
+            });
+        }
+        Ok(())
+    }
+}
 impl players::Host for State {
     fn online(&mut self) -> Vec<ServerPlayer> {
         self.snapshot.players.clone()
@@ -1292,6 +1732,8 @@ const TURN_MIN: f32 = 0.05;
 /// `set-minimap`'s side in GUI pixels and its blocks per map pixel.
 const MINIMAP_SIZE: (f32, f32) = (16.0, 256.0);
 const MINIMAP_SCALE: (f32, f32) = (0.5, 4.0);
+/// `set-far-terrain`'s distance in chunks, as the LOD Distance setting's.
+const FAR_TERRAIN_DISTANCE: (u32, u32) = (64, 1024);
 
 /// A mod's corner panel: shapes in a `width` × `height` box the game
 /// places in `corner`, stacked with the other overlays.
@@ -1381,6 +1823,14 @@ impl render::Host for State {
             ..m
         });
     }
+    fn set_far_terrain(&mut self, far_terrain: Option<ModFarTerrain>) {
+        self.far_terrain = far_terrain.map(|f| ModFarTerrain {
+            distance: f
+                .distance
+                .clamp(FAR_TERRAIN_DISTANCE.0, FAR_TERRAIN_DISTANCE.1),
+            ..f
+        });
+    }
     fn frame_stats(&mut self) -> FrameRate {
         let (fps, min, low) = self.snapshot.frame;
         FrameRate { fps, min, low }
diff --git a/crates/horizon-mods/src/testing.rs b/crates/horizon-mods/src/testing.rs
index 3a7422377..0fe821074 100644
--- a/crates/horizon-mods/src/testing.rs
+++ b/crates/horizon-mods/src/testing.rs
@@ -29,6 +29,54 @@ pub struct TestGame {
     /// Every name that joined, for their id.
     names: Vec<String>,
     tick: u64,
+    /// Capability `world`'s Overworld: the blocks a script set or the mod
+    /// changed; every other block, and the other dimensions, are air. Every
+    /// biome is the dimension's plainest: plains, nether wastes, the end.
+    pub world: std::collections::BTreeMap<(i32, i32, i32), String>,
+}
+
+/// The world a script's mod reads: [`TestGame::world`], copied for a step.
+struct ScriptWorld(std::collections::BTreeMap<(i32, i32, i32), String>);
+
+impl crate::WorldView for ScriptWorld {
+    fn block(&self, dimension: &str, x: i32, y: i32, z: i32) -> Option<String> {
+        let here = (dimension == "minecraft:overworld")
+            .then(|| self.0.get(&(x, y, z)).cloned())
+            .flatten();
+        Some(here.unwrap_or_else(|| "minecraft:air".into()))
+    }
+    fn biome(&self, dimension: &str, _x: i32, _y: i32, _z: i32) -> Option<String> {
+        let biome = match dimension {
+            "minecraft:overworld" => "minecraft:plains",
+            "minecraft:the_nether" => "minecraft:nether_wastes",
+            "minecraft:the_end" => "minecraft:the_end",
+            _ => return None,
+        };
+        Some(biome.into())
+    }
+    fn has_dimension(&self, dimension: &str) -> bool {
+        matches!(
+            dimension,
+            "minecraft:overworld" | "minecraft:the_nether" | "minecraft:the_end"
+        )
+    }
+    fn check_state(&self, state: &str) -> Result<(), String> {
+        // No registry here: the shape only (the game checks the names).
+        let name = state.split('[').next().unwrap_or_default();
+        let plain = |t: &str| {
+            !t.is_empty()
+                && t.bytes()
+                    .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b"_.-/".contains(&b))
+        };
+        let ok = match name.split_once(':') {
+            Some((ns, path)) => plain(ns) && plain(path),
+            None => plain(name),
+        };
+        let closed = !state.contains('[') || state.ends_with(']');
+        (ok && closed)
+            .then_some(())
+            .ok_or_else(|| format!("{state} is not a block state"))
+    }
 }
 
 /// Where a script starts: standing at 0.5 64 0.5 in the Overworld, facing
@@ -71,6 +119,7 @@ impl TestGame {
             players: Vec::new(),
             names: Vec::new(),
             tick: 0,
+            world: Default::default(),
         };
         copy_mod(hmod, &copy)?;
         game.start()?;
@@ -204,7 +253,7 @@ impl TestGame {
     }
     /// The commands the mod registered.
     pub fn commands(&self) -> Vec<String> {
-        let server = self.mods.server_commands();
+        let server = self.mods.server_commands().map(|c| c.name.as_str());
         self.mods
             .commands()
             .chain(server)
@@ -312,9 +361,10 @@ pub struct ClockSet {
 }
 
 /// One step. Its parts happen in this order: `reload`, `title-screen`,
-/// `join`, `player`, `clock`, `ticks`, `frames`, `chat`, `command`, `break`,
-/// `place`, `leave`; then `expect` is checked against what the mod showed
-/// during the step. For a server mod, `player`, `chat`, `command`, `break`
+/// `blocks`, `join`, `player`, `clock`, `ticks`, `frames`, `chat`, `command`,
+/// `break`, `place`, `leave`; then the blocks the mod set are made, and
+/// `expect` is checked against what the mod showed and changed during the
+/// step. For a server mod, `player`, `chat`, `command`, `break`
 /// and `place` are the doing of the player named by `as`, or of the first
 /// player on.
 #[derive(Debug, Default, Deserialize)]
@@ -341,6 +391,10 @@ pub struct Step {
     #[serde(rename = "break")]
     broken: Option<BlockSet>,
     place: Option<BlockSet>,
+    /// Blocks of the Overworld before the rest of the step (capability
+    /// `world`); every other block is air.
+    #[serde(default)]
+    blocks: Vec<BlockSet>,
     #[serde(default)]
     expect: Expect,
 }
@@ -363,6 +417,9 @@ pub struct Expect {
     /// The panel's lines (`[]`: no panel) and its corner.
     panel: Option<Vec<String>>,
     corner: Option<String>,
+    /// Blocks of the Overworld after the step, the mod's changes made
+    /// (capability `world`).
+    blocks: Option<Vec<BlockSet>>,
     /// The mod is turned off during this step, for a reason holding this text.
     /// Without it, a mod that stops fails the test.
     stopped: Option<String>,
@@ -467,6 +524,11 @@ impl Step {
             game.player = None;
             game.clock = None;
         }
+        for b in &self.blocks {
+            game.world.insert((b.x, b.y, b.z), b.state.clone());
+        }
+        game.mods
+            .lend_world(Box::new(ScriptWorld(game.world.clone())));
         if let Some(name) = &self.join {
             game.join(name);
         }
@@ -531,7 +593,19 @@ impl Step {
         {
             return Err(format!("{name} is not on the server"));
         }
+        game.mods.take_world();
         let out = game.drain();
+        for o in &out {
+            if let Output::SetBlocks {
+                dimension, blocks, ..
+            } = o
+                && dimension == "minecraft:overworld"
+            {
+                for b in blocks {
+                    game.world.insert((b.x, b.y, b.z), b.state.clone());
+                }
+            }
+        }
         let stopped = out.iter().find_map(|o| match o {
             Output::Stopped { reason, .. } => Some(reason.as_str()),
             _ => None,
@@ -615,6 +689,18 @@ impl Step {
                 .unwrap_or_default();
             same("panel", want, &got)?;
         }
+        if let Some(want) = &e.blocks {
+            for b in want {
+                let got = game.world.get(&(b.x, b.y, b.z));
+                let got = got.map_or("minecraft:air", String::as_str);
+                if got != b.state {
+                    return Err(format!(
+                        "block at {} {} {}: expected {}, got {got}",
+                        b.x, b.y, b.z, b.state
+                    ));
+                }
+            }
+        }
         if let Some(want) = &e.corner {
             let got = game.panel().map(|p| corner_name(p.corner).to_string());
             same("corner", &Some(want.clone()), &got)?;
diff --git a/crates/horizon-mods/tests/sandbox.rs b/crates/horizon-mods/tests/sandbox.rs
index c6b835f10..e400dd56b 100644
--- a/crates/horizon-mods/tests/sandbox.rs
+++ b/crates/horizon-mods/tests/sandbox.rs
@@ -26,8 +26,8 @@ id = "test_ui_guest"
 name = "Test UI Guest"
 version = "0.1.0"
 api = "0.1"
-capabilities = ["game-read", "chat", "command", "ui", "render", "input"]
-experimental = ["ui", "render", "input"]
+capabilities = ["game-read", "chat", "command", "ui", "render", "input", "recipes"]
+experimental = ["ui", "render", "input", "recipes"]
 "#;
 
 /// Builds the mods once and writes their `.hmod` files; returns the folder.
@@ -47,6 +47,8 @@ fn mods_dir() -> &'static Path {
                 "-p",
                 "welcome",
                 "-p",
+                "beacons",
+                "-p",
                 "horizon-mods-test-guest",
                 "-p",
                 "horizon-mods-test-ui-guest",
@@ -70,6 +72,7 @@ fn mods_dir() -> &'static Path {
             ("coords_hud", example("coords-hud")),
             ("predator_missile", example("predator-missile")),
             ("welcome", example("welcome")),
+            ("beacons", example("beacons")),
             ("horizon_mods_test_guest", GUEST_MANIFEST.to_string()),
             ("horizon_mods_test_ui_guest", UI_MANIFEST.to_string()),
         ];
@@ -238,8 +241,8 @@ id = "too_new"
 name = "Too New"
 version = "0.1.0"
 api = "0.1"
-capabilities = ["game-read", "chat", "hud", "storage", "command", "ui", "render", "input"]
-experimental = ["ui", "render", "input"]
+capabilities = ["game-read", "chat", "hud", "storage", "command", "ui", "render", "input", "recipes"]
+experimental = ["ui", "render", "input", "recipes"]
 "#;
     std::fs::write(dir.join("horizon-mod.toml"), manifest).unwrap();
     std::fs::write(dir.join("mod.wasm"), wasm).unwrap();
@@ -252,7 +255,7 @@ experimental = ["ui", "render", "input"]
         needed(imports(&wasm).unwrap().iter().map(String::as_str)).0
     };
     assert_eq!(level("coords_hud.hmod"), 0);
-    // The UI guest shows a minimap (`render.set-minimap`).
+    // The UI guest draws far terrain (`render.set-far-terrain`).
     assert_eq!(level("horizon_mods_test_ui_guest.hmod"), LEVEL);
 }
 
@@ -722,6 +725,21 @@ fn render_minimap_is_clamped_and_hidden() {
     assert_eq!(map(&mut mods, "off"), None);
 }
 
+#[test]
+fn render_far_terrain_is_clamped_and_ended() {
+    let mut mods = load("horizon_mods_test_ui_guest.hmod");
+    let far = |mods: &mut Mods, args: &str| {
+        assert!(mods.command(&format!("far_terrain {args}")));
+        mods.far_terrain().map(|f| (f.distance, f.reduced))
+    };
+    assert!(mods.far_terrain().is_none());
+    assert_eq!(far(&mut mods, "256 1"), Some((256, true)));
+    // The distance is clamped to LOD Distance's 64 to 1024 chunks.
+    assert_eq!(far(&mut mods, "8 0"), Some((64, false)));
+    assert_eq!(far(&mut mods, "99999 0"), Some((1024, false)));
+    assert_eq!(far(&mut mods, "off"), None);
+}
+
 /// `game.raycast`: the view's hit the game worked out, up to the distance
 /// asked for; the game works it out only while a mod imports the call.
 #[test]
@@ -866,7 +884,12 @@ capabilities = ["registries"]
 fn the_examples_test_scripts_pass() {
     let examples = Path::new(env!("CARGO_MANIFEST_DIR")).join("../horizon-mod-sdk/examples");
     let mut ran = 0;
-    for (example, hmod) in [("coords-hud", "coords_hud"), ("welcome", "welcome")] {
+    let examples_and_files = [
+        ("coords-hud", "coords_hud"),
+        ("welcome", "welcome"),
+        ("beacons", "beacons"),
+    ];
+    for (example, hmod) in examples_and_files {
         for entry in std::fs::read_dir(examples.join(example).join("tests")).unwrap() {
             let path = entry.unwrap().path();
             let script = Script::parse(&std::fs::read_to_string(&path).unwrap()).unwrap();
@@ -877,7 +900,24 @@ fn the_examples_test_scripts_pass() {
             ran += 1;
         }
     }
-    assert_eq!(ran, 4);
+    assert_eq!(ran, 5);
+}
+
+/// Capability `world` without a world lent (the registry's trial run):
+/// `get-block` finds nothing, `set-blocks` checks its count and queues.
+#[test]
+fn a_server_mod_without_a_world_reads_nothing() {
+    let mut game = TestGame::load(&mods_dir().join("beacons.hmod")).unwrap();
+    game.join("Alex");
+    let alex = game.players[0].clone();
+    assert!(game.player_command(&alex, "ground"));
+    let out = game.drain();
+    assert!(
+        out.iter()
+            .any(|o| matches!(o, Output::Reply { text, error: true, .. }
+            if text == "That block isn't loaded")),
+        "{out:?}"
+    );
 }
 
 #[test]
@@ -974,10 +1014,12 @@ fn a_server_mod_runs_only_where_the_world_does() {
 
     let mut mods = Mods::load_for(Runs::Server, paths, |_| true, |c| c == "give");
     assert!(mods.runs_server());
-    assert_eq!(
-        mods.server_commands().collect::<Vec<_>>(),
-        ["online", "mined"]
-    );
+    let commands: Vec<_> = mods.server_commands().map(|c| c.name.as_str()).collect();
+    assert_eq!(commands, ["online", "mined"]);
+    // `/mined [player]`: its argument travels with it, for the command tree.
+    let mined = mods.server_commands().nth(1).unwrap();
+    assert_eq!(mined.arguments[0].kind, horizon_mods::ArgumentKind::Player);
+    assert!(mined.arguments[0].optional);
     assert_eq!(mods.commands().count(), 0, "not the window's chat commands");
     let alex = alex();
     mods.set_snapshot(Snapshot {
@@ -1016,3 +1058,247 @@ fn a_server_mod_runs_only_where_the_world_does() {
         "a server command isn't the window's"
     );
 }
+
+/// Capability `recipes`: the guest reads tables as big as vanilla's (1,500
+/// items, 1,600 recipes of nine five-item slots) within one command's fuel.
+#[test]
+fn recipes_reads_the_tables() {
+    use horizon_mods::{Recipe, RecipeItem, RecipeKind, RecipeStack, Recipes};
+    let mut mods = load("horizon_mods_test_ui_guest.hmod");
+    let stack = |item| RecipeStack {
+        item,
+        count: 1,
+        components: String::new(),
+    };
+    let items = (0..1500)
+        .map(|i| RecipeItem {
+            id: format!("minecraft:item_{i}"),
+            name: format!("Item {i}"),
+            tags: vec!["planks".into(), "logs".into()],
+        })
+        .collect();
+    let mut recipes: Vec<Recipe> = (0..1600)
+        .map(|i| Recipe {
+            id: format!("minecraft:recipe_{i}"),
+            kind: RecipeKind::CraftingShaped,
+            category: "crafting_misc".into(),
+            group: String::new(),
+            width: 3,
+            height: 3,
+            slots: (0..9)
+                .map(|k| (0..5).map(|j| stack((i + k + j) % 1500)).collect())
+                .collect(),
+            results: vec![RecipeStack {
+                item: 7,
+                count: 4,
+                components: String::new(),
+            }],
+            cooking_time: 0,
+            experience: 0.0,
+            book_id: i as i32,
+        })
+        .collect();
+    recipes[1].kind = RecipeKind::Brewing;
+    recipes[1].results[0].components =
+        "[minecraft:potion_contents={potion:\"minecraft:swiftness\"}]".into();
+    let mods_recipes = Some(std::sync::Arc::new(Recipes { items, recipes }));
+    mods.set_snapshot(Snapshot {
+        recipes: mods_recipes.clone(),
+        known_recipes: vec![1, 5, 9].into(),
+        ..Snapshot::default()
+    });
+    let said = |mods: &mut Mods, command: &str| {
+        assert!(mods.command(command));
+        mods.drain()
+            .into_iter()
+            .filter_map(|o| match o {
+                Output::Chat { text, .. } => Some(text),
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+    };
+    assert_eq!(
+        said(&mut mods, "recipes"),
+        ["1500 items, 1600 recipes, 3 known, 1 brewing"]
+    );
+    assert_eq!(
+        said(&mut mods, "recipes minecraft:recipe_1"),
+        [
+            "minecraft:recipe_1 Kind::Brewing 3x3 0t slots 9, the first 1 minecraft:item_1 -> \
+          4 minecraft:item_7[minecraft:potion_contents={potion:\"minecraft:swiftness\"}] known true"
+        ]
+    );
+    assert!(
+        mods.entries()
+            .iter()
+            .all(|e| e.status == horizon_mods::Status::Running),
+        "it ran out of fuel"
+    );
+    // Actions: refused without a crafting screen, for an unknown recipe,
+    // and outside creative mode.
+    assert_eq!(
+        said(&mut mods, "recipe_place minecraft:recipe_5"),
+        ["place minecraft:recipe_5: no screen that takes recipes is open"]
+    );
+    let mut snap = Snapshot {
+        recipes: mods_recipes.clone(),
+        known_recipes: vec![1, 5, 9].into(),
+        placing: true,
+        ..Snapshot::default()
+    };
+    mods.set_snapshot(snap.clone());
+    assert_eq!(
+        said(&mut mods, "recipe_place minecraft:recipe_6"),
+        ["place minecraft:recipe_6: recipe 6 is not in the player's recipe book"]
+    );
+    assert!(mods.command("recipe_place minecraft:recipe_5 all"));
+    assert_eq!(
+        mods.drain()[0],
+        Output::PlaceRecipe {
+            book_id: 5,
+            all: true
+        }
+    );
+    assert_eq!(
+        said(&mut mods, "recipe_give minecraft:item_7 3"),
+        ["give minecraft:item_7: only in creative mode"]
+    );
+    snap.creative = true;
+    mods.set_snapshot(snap);
+    assert!(mods.command("recipe_give minecraft:item_7 3"));
+    assert_eq!(
+        mods.drain()[0],
+        Output::Give {
+            item: "minecraft:item_7".into(),
+            count: 3,
+            components: String::new()
+        }
+    );
+    // Without the game's tables (no mod read them yet): empty, not a trap.
+    mods.set_snapshot(Snapshot::default());
+    assert_eq!(
+        said(&mut mods, "recipes"),
+        ["0 items, 0 recipes, 0 known, 0 brewing"]
+    );
+}
+
+#[test]
+fn browser_lists_items_and_hears_the_player() {
+    use horizon_mods::{BrowserClick, BrowserEvent, BrowserStack};
+    let mut mods = load("horizon_mods_test_ui_guest.hmod");
+    let said = |mods: &mut Mods, command: &str| {
+        assert!(mods.command(command));
+        mods.drain()
+            .into_iter()
+            .filter_map(|o| match o {
+                Output::Chat { text, .. } => Some(text),
+                _ => None,
+            })
+            .collect::<Vec<_>>()
+    };
+    assert!(mods.browser_items().is_none());
+    let potion = "[minecraft:potion_contents={potion:\"minecraft:swiftness\"}]";
+    assert_eq!(
+        said(
+            &mut mods,
+            &format!("browser minecraft:stone minecraft:potion{potion}")
+        ),
+        ["panel of 2"]
+    );
+    let (owner, version, items) = mods.browser_items().unwrap();
+    assert_eq!(
+        (items[0].item.as_str(), items[1].components.as_str()),
+        ("minecraft:stone", potion)
+    );
+    mods.browser_event(
+        owner,
+        BrowserEvent::Clicked(BrowserClick {
+            index: 1,
+            right: true,
+        }),
+    );
+    mods.browser_event(owner, BrowserEvent::Search("oak".into()));
+    let log = BrowserStack {
+        item: "minecraft:oak_log".into(),
+        count: 3,
+        components: String::new(),
+    };
+    // R is the guest's `recipe`; X is none of its keys.
+    mods.browser_key("key.keyboard.r", &log);
+    mods.browser_key("key.keyboard.x", &log);
+    assert_eq!(
+        said(&mut mods, "browser_poll"),
+        [
+            "3 events",
+            "clicked 1 right",
+            "search \"oak\"",
+            "key recipe on minecraft:oak_log x3"
+        ]
+    );
+    // Each `set-items` is a new version; an empty list hides the panel.
+    said(&mut mods, "browser minecraft:dirt");
+    assert_ne!(mods.browser_items().unwrap().1, version);
+    assert_eq!(said(&mut mods, "browser"), ["panel of 0"]);
+    assert!(mods.browser_items().is_none());
+    // Recipes in the panel's place: the guest shows those making planks.
+    use horizon_mods::{BrowserLayout, Recipe, RecipeItem, RecipeKind, RecipeStack, Recipes};
+    let item = |id: &str| RecipeItem {
+        id: id.into(),
+        name: id.into(),
+        tags: Vec::new(),
+    };
+    let stack = |item| RecipeStack {
+        item,
+        count: 1,
+        components: String::new(),
+    };
+    mods.set_snapshot(Snapshot {
+        recipes: Some(std::sync::Arc::new(Recipes {
+            items: vec![item("minecraft:oak_log"), item("minecraft:oak_planks")],
+            recipes: vec![Recipe {
+                id: "minecraft:oak_planks".into(),
+                kind: RecipeKind::CraftingShapeless,
+                category: "building".into(),
+                group: "planks".into(),
+                width: 0,
+                height: 0,
+                slots: vec![vec![stack(0)]],
+                results: vec![RecipeStack {
+                    count: 4,
+                    ..stack(1)
+                }],
+                cooking_time: 0,
+                experience: 0.0,
+                book_id: 1,
+            }],
+        })),
+        ..Snapshot::default()
+    });
+    said(&mut mods, "browser minecraft:dirt");
+    assert_eq!(
+        said(&mut mods, "browser_recipes minecraft:oak_planks"),
+        ["recipes shown: 1"]
+    );
+    let page = mods.browser_recipes(owner).unwrap();
+    assert_eq!(page.title, "Recipes for minecraft:oak_planks");
+    assert_eq!(
+        (page.tabs[0].item.as_str(), page.tab),
+        ("minecraft:crafting_table", 0)
+    );
+    let r = &page.recipes[0];
+    assert_eq!(
+        (r.layout, r.width, r.height, r.action),
+        (BrowserLayout::Grid, 1, 1, Some(false))
+    );
+    assert_eq!(
+        (r.slots[0][0].item.as_str(), r.results[0].count),
+        ("minecraft:oak_log", 4)
+    );
+    assert_eq!(said(&mut mods, "browser_recipes"), ["recipes shown: 0"]);
+    assert!(mods.browser_recipes(owner).is_none());
+    // At most 256 events wait for a poll: the oldest go.
+    for _ in 0..300 {
+        mods.browser_event(owner, BrowserEvent::Page(1));
+    }
+    assert_eq!(said(&mut mods, "browser_poll")[0], "256 events");
+}
diff --git a/crates/horizon-mods/tests/ui_guest/src/lib.rs b/crates/horizon-mods/tests/ui_guest/src/lib.rs
index 74fb64350..f95aedffa 100644
--- a/crates/horizon-mods/tests/ui_guest/src/lib.rs
+++ b/crates/horizon-mods/tests/ui_guest/src/lib.rs
@@ -6,10 +6,19 @@
 //! `input`; `/zoom FACTOR SMOOTH TURN` tests `render.set-zoom`;
 //! `/corner` and `/readings` the calls the official extras mods use;
 //! `/raycast DISTANCE` says what `game.raycast` sees; `/quiet A;B` runs
-//! lines with `command.run-quiet` (`/quiet_many N`: N of them).
+//! lines with `command.run-quiet` (`/quiet_many N`: N of them). `/recipes`
+//! counts what `recipes` reads; `/recipes ID` describes that recipe.
+//! `/browser ID...` fills `browser`'s panel (`/browser N`: the first N
+//! items, `/browser` alone empties it) and registers the keys `recipe` (R)
+//! and `uses` (U); `/browser_poll` says what the player did on it;
+//! `/browser_recipes ID` shows the recipes making ID (`/browser_recipes`
+//! alone: the items again). `/recipe_place ID [all]` places that recipe
+//! with `recipes.place`; `/recipe_give ITEM [COUNT]` gives with
+//! `recipes.give`.
 use horizon_mod_sdk::{
-    Mod, Registration, chat, command, game,
+    Mod, Registration, browser, chat, command, game,
     input::{self, Event},
+    recipes,
     render::{self, FillShape, ItemShape, Point, QuadShape, Rect, Shape, SpriteShape, TextShape},
     ui::{self, ItemWidget, ListWidget, Screen, TextWidget, Widget},
 };
@@ -62,7 +71,11 @@ fn shapes() -> Vec<Shape> {
     ]
 }
 
-struct Guest;
+struct Guest {
+    /// `/recipe_place ID [all] later`: placed on the first tick a crafting
+    /// screen is open.
+    pending: Option<(i32, bool, String)>,
+}
 
 fn widgets() -> Vec<Widget> {
     vec![
@@ -99,15 +112,23 @@ impl Mod for Guest {
             "input_wheel",
             "zoom",
             "minimap",
+            "far_terrain",
             "raycast",
             "quiet",
             "quiet_many",
+            "recipes",
+            "browser",
+            "browser_poll",
+            "browser_recipes",
+            "recipe_place",
+            "recipe_give",
             "corner",
             "readings",
         ]
         .into_iter()
-        .fold(Registration::new(), Registration::command);
-        Ok((Guest, hooks))
+        .fold(Registration::new(), Registration::command)
+        .on_tick();
+        Ok((Guest { pending: None }, hooks))
     }
     fn command(&mut self, name: &str, args: &str) -> Result<Option<String>, String> {
         match name {
@@ -222,6 +243,15 @@ impl Mod for Guest {
                 });
                 render::set_minimap(map);
             }
+            // `far_terrain off`, or `far_terrain DISTANCE REDUCED`.
+            "far_terrain" => {
+                let words: Vec<&str> = args.split(' ').collect();
+                let far = (args != "off").then(|| render::FarTerrain {
+                    distance: words.first().and_then(|w| w.parse().ok()).unwrap_or(0),
+                    reduced: words.get(1) == Some(&"1"),
+                });
+                render::set_far_terrain(far);
+            }
             "quiet" => command::run_quiet(&args.split(';').map(str::to_owned).collect::<Vec<_>>()),
             "quiet_many" => {
                 let n: usize = args.parse().unwrap_or(0);
@@ -241,6 +271,203 @@ impl Mod for Guest {
                     None => "no hit".into(),
                 });
             }
+            "recipes" => {
+                let items = recipes::items();
+                let all = recipes::all();
+                let known = recipes::known();
+                let name = |s: &recipes::Stack| {
+                    let id = items.get(s.item as usize).map_or("?", |i| i.id.as_str());
+                    format!("{} {id}{}", s.count, s.components)
+                };
+                chat::show(&match all.iter().find(|r| r.id == args) {
+                    Some(r) => format!(
+                        "{} {:?} {}x{} {}t slots {}, the first {} -> {} known {}",
+                        r.id,
+                        r.kind,
+                        r.width,
+                        r.height,
+                        r.cooking_time,
+                        r.slots.len(),
+                        r.slots
+                            .first()
+                            .and_then(|s| s.first())
+                            .map_or("-".into(), name),
+                        r.results.first().map_or("-".into(), name),
+                        known.contains(&r.book_id)
+                    ),
+                    None => format!(
+                        "{} items, {} recipes, {} known, {} brewing",
+                        items.len(),
+                        all.len(),
+                        known.len(),
+                        all.iter()
+                            .filter(|r| r.kind == recipes::Kind::Brewing)
+                            .count()
+                    ),
+                });
+            }
+            "browser" => {
+                let stack = |item: &str| {
+                    let (item, components) = match item.find('[') {
+                        Some(at) => (&item[..at], &item[at..]),
+                        None => (item, ""),
+                    };
+                    browser::Stack {
+                        item: item.into(),
+                        count: 1,
+                        components: components.into(),
+                    }
+                };
+                let items: Vec<browser::Stack> = match args.parse::<usize>() {
+                    Ok(n) => recipes::items()
+                        .iter()
+                        .skip(1)
+                        .take(n)
+                        .map(|i| stack(&i.id))
+                        .collect(),
+                    Err(_) => args.split_whitespace().map(stack).collect(),
+                };
+                browser::set_items(&items);
+                input::register_key("recipe", "Show recipes", "key.keyboard.r")?;
+                input::register_key("uses", "Show uses", "key.keyboard.u")?;
+                chat::show(&format!("panel of {}", items.len()));
+            }
+            "browser_recipes" => {
+                let items = recipes::items();
+                let id = |i: u32| {
+                    items
+                        .get(i as usize)
+                        .map_or(String::new(), |x| x.id.clone())
+                };
+                let stack = |s: &recipes::Stack| browser::Stack {
+                    item: id(s.item),
+                    count: s.count,
+                    components: s.components.clone(),
+                };
+                let views: Vec<browser::RecipeView> = recipes::all()
+                    .iter()
+                    .filter(|r| !args.is_empty() && r.results.iter().any(|s| id(s.item) == args))
+                    .map(|r| {
+                        use recipes::Kind;
+                        let crafting =
+                            matches!(r.kind, Kind::CraftingShaped | Kind::CraftingShapeless);
+                        let shapeless = (r.slots.len() as u32).clamp(1, 3);
+                        browser::RecipeView {
+                            layout: match r.kind {
+                                Kind::CraftingShaped | Kind::CraftingShapeless => {
+                                    browser::Layout::Grid
+                                }
+                                Kind::Stonecutting => browser::Layout::Single,
+                                Kind::Smithing => browser::Layout::Smithing,
+                                Kind::Brewing => browser::Layout::Brewing,
+                                _ => browser::Layout::Cooking,
+                            },
+                            width: if r.width == 0 { shapeless } else { r.width },
+                            height: if r.height == 0 {
+                                (r.slots.len() as u32).div_ceil(3).max(1)
+                            } else {
+                                r.height
+                            },
+                            slots: r
+                                .slots
+                                .iter()
+                                .map(|s| s.iter().map(stack).collect())
+                                .collect(),
+                            results: r.results.iter().map(stack).collect(),
+                            note: if r.cooking_time > 0 {
+                                format!("{} ticks", r.cooking_time)
+                            } else {
+                                String::new()
+                            },
+                            action: crafting.then_some(r.kind == Kind::CraftingShaped),
+                        }
+                    })
+                    .collect();
+                // A tab per layout shown, the first selected.
+                let mut tabs: Vec<browser::Stack> = Vec::new();
+                for v in &views {
+                    let icon = match v.layout {
+                        browser::Layout::Grid => "minecraft:crafting_table",
+                        browser::Layout::Cooking => "minecraft:furnace",
+                        browser::Layout::Single => "minecraft:stonecutter",
+                        browser::Layout::Smithing => "minecraft:smithing_table",
+                        browser::Layout::Brewing => "minecraft:brewing_stand",
+                    };
+                    if !tabs.iter().any(|t| t.item == icon) {
+                        tabs.push(browser::Stack {
+                            item: icon.into(),
+                            count: 1,
+                            components: String::new(),
+                        });
+                    }
+                }
+                browser::set_recipes(&format!("Recipes for {args}"), &tabs, 0, &views);
+                chat::show(&format!("recipes shown: {}", views.len()));
+            }
+            "recipe_place" => {
+                let mut words = args.split_whitespace();
+                let id = words.next().unwrap_or_default();
+                let rest: Vec<&str> = words.collect();
+                let all = rest.contains(&"all");
+                let book = recipes::all()
+                    .iter()
+                    .find(|r| r.id == id)
+                    .map(|r| r.book_id);
+                if let Some(b) = book.filter(|_| rest.contains(&"later")) {
+                    self.pending = Some((b, all, id.to_owned()));
+                    chat::show(&format!("place {id}: waiting"));
+                    return Ok(None);
+                }
+                chat::show(&match book.map(|b| recipes::place(b, all)) {
+                    Some(Ok(())) => format!("place {id}: ok"),
+                    Some(Err(e)) => format!("place {id}: {e}"),
+                    None => format!("place {id}: no such recipe"),
+                });
+            }
+            "recipe_give" => {
+                let mut words = args.split_whitespace();
+                let id = words.next().unwrap_or_default();
+                let count = words.next().and_then(|c| c.parse().ok()).unwrap_or(1);
+                let item = recipes::items().iter().position(|i| i.id == id);
+                let result = item.map(|i| {
+                    recipes::give(&recipes::Stack {
+                        item: i as u32,
+                        count,
+                        components: String::new(),
+                    })
+                });
+                chat::show(&match result {
+                    Some(Ok(())) => format!("give {id}: ok"),
+                    Some(Err(e)) => format!("give {id}: {e}"),
+                    None => format!("give {id}: no such item"),
+                });
+            }
+            "browser_poll" => {
+                let stack = |s: &browser::Stack| format!("{} x{}{}", s.item, s.count, s.components);
+                // A hook shows at most 8 chat lines: the count, then the first 7.
+                let events = browser::poll();
+                chat::show(&format!("{} events", events.len()));
+                for event in events.into_iter().take(7) {
+                    chat::show(&match event {
+                        browser::Event::Clicked(c) => {
+                            format!(
+                                "clicked {} {}",
+                                c.index,
+                                if c.right { "right" } else { "left" }
+                            )
+                        }
+                        browser::Event::Search(text) => format!("search {text:?}"),
+                        browser::Event::Key(k) => format!("key {} on {}", k.key, stack(&k.stack)),
+                        browser::Event::SlotClicked(c) => {
+                            format!("slot {} {} {}", c.recipe, c.slot, stack(&c.stack))
+                        }
+                        browser::Event::Action(i) => format!("action {i}"),
+                        browser::Event::Page(first) => format!("page {first}"),
+                        browser::Event::Back => "back".into(),
+                        browser::Event::Tab(i) => format!("tab {i}"),
+                    });
+                }
+            }
             // Clamped to (1, 10); the two after it shake nothing.
             "render_shake" => {
                 render::shake(2.0, 99.0);
@@ -251,6 +478,15 @@ impl Mod for Guest {
         }
         Ok(None)
     }
+    fn tick(&mut self, _tick: u64) {
+        if let Some((book, all, id)) = self.pending.take() {
+            match recipes::place(book, all) {
+                Err(e) if e.starts_with("no screen") => self.pending = Some((book, all, id)),
+                Ok(()) => chat::show(&format!("place {id}: ok")),
+                Err(e) => chat::show(&format!("place {id}: {e}")),
+            }
+        }
+    }
     fn ui_select(&mut self, id: u32, row: u32) {
         chat::show(&format!("selected {id}:{row}"));
     }
diff --git a/crates/horizon-protocol/src/packets/configuration.rs b/crates/horizon-protocol/src/packets/configuration.rs
index ced56dacf..22a8a1456 100644
--- a/crates/horizon-protocol/src/packets/configuration.rs
+++ b/crates/horizon-protocol/src/packets/configuration.rs
@@ -45,6 +45,54 @@ packet!(
 packet!(KnownPack { namespace: String => Str, id: String => Str, version: String => Str });
 packet!(SelectKnownPacks { packs: Vec<KnownPack> => List<KnownPack> });
 packet!(CodeOfConduct { text: String => Str });
+
+/// ServerLinks.UntrustedEntry's `type` (Either<KnownLinkType, Component>): a
+/// known link's id, or a custom label component.
+#[derive(Clone, Debug, PartialEq)]
+pub enum ServerLinkKind {
+    /// ServerLinks.KnownLinkType by id (ByIdMap: unknown ids read as 0).
+    Known(i32),
+    /// A custom label (TRUSTED_CONTEXT_FREE_STREAM_CODEC: a component in NBT).
+    Custom(Tag),
+}
+/// ServerLinks.UntrustedEntry: the label and the unchecked link string (the
+/// client keeps only `http`/`https` URIs, Util.parseAndValidateUntrustedUri).
+#[derive(Clone, Debug, PartialEq)]
+pub struct ServerLink {
+    pub kind: ServerLinkKind,
+    pub link: String,
+}
+impl Codec<ServerLink> for ServerLink {
+    fn read(r: &mut Reader) -> Result<Self> {
+        let kind = if Bool::read(r)? {
+            ServerLinkKind::Known(VarInt::read(r)?)
+        } else {
+            ServerLinkKind::Custom(Nbt::read(r)?)
+        };
+        Ok(Self {
+            kind,
+            link: Str::read(r)?,
+        })
+    }
+    fn write(v: &Self, w: &mut Writer) {
+        match &v.kind {
+            ServerLinkKind::Known(id) => {
+                Bool::write(&true, w);
+                VarInt::write(id, w);
+            }
+            ServerLinkKind::Custom(tag) => {
+                Bool::write(&false, w);
+                Nbt::write(tag, w);
+            }
+        }
+        Str::write(&v.link, w);
+    }
+}
+packet!(
+    /// ClientboundServerLinksPacket (a common packet: configuration and play).
+    /// Links the pause menu's "Server Links..." screen lists.
+    ServerLinks { links: Vec<ServerLink> => List<ServerLink> }
+);
 packet!(
     /// ClientboundShowDialogPacket.CONTEXT_FREE_STREAM_CODEC: the dialog
     /// itself (`Dialog.DIRECT_CODEC` as NBT).
@@ -89,6 +137,7 @@ packet_enum!(Clientbound, crate::ids::configuration::clientbound {
     UpdateTags(UpdateTags) = UPDATE_TAGS,
     SelectKnownPacks(SelectKnownPacks) = SELECT_KNOWN_PACKS,
     ClearDialog(Empty) = CLEAR_DIALOG,
+    ServerLinks(ServerLinks) = SERVER_LINKS,
     ShowDialog(ShowDialog) = SHOW_DIALOG,
     CodeOfConduct(CodeOfConduct) = CODE_OF_CONDUCT,
 });
@@ -236,6 +285,18 @@ mod tests {
             Clientbound::CodeOfConduct(CodeOfConduct {
                 text: "Be nice".into(),
             }),
+            Clientbound::ServerLinks(ServerLinks {
+                links: vec![
+                    ServerLink {
+                        kind: ServerLinkKind::Known(0),
+                        link: "https://bugs.example.net".into(),
+                    },
+                    ServerLink {
+                        kind: ServerLinkKind::Custom(crate::text::literal("Custom link")),
+                        link: "https://example.net".into(),
+                    },
+                ],
+            }),
             Clientbound::ShowDialog(ShowDialog {
                 dialog: Tag::compound([("type", Tag::String("minecraft:notice".into()))]),
             }),
diff --git a/crates/horizon-protocol/src/packets/play.rs b/crates/horizon-protocol/src/packets/play.rs
index 26bc09a84..0229706ce 100644
--- a/crates/horizon-protocol/src/packets/play.rs
+++ b/crates/horizon-protocol/src/packets/play.rs
@@ -15,7 +15,7 @@ use crate::{
         configuration::{
             ClientInformation, CookieRequest, CookieResponse, CustomClickAction, CustomPayload,
             Disconnect, KeepAlive, Ping, ResourcePackPop, ResourcePackPush, ResourcePackResponse,
-            StoreCookie, Transfer, UpdateTags,
+            ServerLinks, StoreCookie, Transfer, UpdateTags,
         },
         login::Property,
     },
@@ -1903,6 +1903,9 @@ packet_enum!(Clientbound, crate::ids::play::clientbound {
     StopSound(StopSound) = STOP_SOUND,
     StartConfiguration(Empty) = START_CONFIGURATION,
     StoreCookie(StoreCookie) = STORE_COOKIE,
+    // A common packet: the same `configuration::ServerLinks` the
+    // configuration phase sends.
+    ServerLinks(ServerLinks) = SERVER_LINKS,
     SwingAnimation(SwingAnimation) = SWING_ANIMATION,
     SystemChat(SystemChat) = SYSTEM_CHAT,
     TabList(TabList) = TAB_LIST,
@@ -2160,6 +2163,12 @@ packet!(
     /// ServerboundSignUpdatePacket: the four lines the player wrote on a side.
     SignUpdate { pos: [i32; 3] => Pos, lines: [String; 4] => SignLines, front: bool => SignSide }
 );
+packet!(
+    /// ServerboundSetCommandBlockPacket: the command block's command, its
+    /// mode (`CommandBlockEntity.Mode` ordinal) and the track output (1),
+    /// conditional (2) and automatic (4) flags.
+    SetCommandBlock { pos: [i32; 3] => Pos, command: String => Str, mode: i32 => VarInt, flags: i8 => Byte }
+);
 packet!(
     /// ServerboundEditBookPacket: the book's slot (a hotbar slot, or 40 for
     /// the off hand), its pages and, to sign it, its title.
@@ -2249,6 +2258,11 @@ packet!(
     /// Input flags: forward 1, backward 2, left 4, right 8, jump 16, shift 32, sprint 64.
     PlayerInput { flags: u8 => UByte }
 );
+packet!(
+    /// ServerboundSelectBundleItemPacket: the menu slot of a bundle and the
+    /// index of its selected item (-1: none).
+    SelectBundleItem { slot: i32 => VarInt, index: i32 => VarInt }
+);
 packet!(SetCarriedItem { slot: i16 => Short });
 packet!(SetCreativeModeSlot { slot: i16 => Short, item: Option<Stack> => Slot });
 packet!(UseItem { hand: i32 => VarInt, sequence: i32 => VarInt, yaw: f32 => Float, pitch: f32 => Float });
@@ -2285,6 +2299,7 @@ packet_enum!(Serverbound, crate::ids::play::serverbound {
     ChatCommandSigned(ChatCommandSigned) = CHAT_COMMAND_SIGNED,
     ChatSessionUpdate(ChatSessionUpdate) = CHAT_SESSION_UPDATE,
     PlaceRecipe(super::recipes::PlaceRecipe) = PLACE_RECIPE,
+    RecipeBookChangeSettings(super::recipes::RecipeBookChangeSettings) = RECIPE_BOOK_CHANGE_SETTINGS,
     ChunkBatchReceived(ChunkBatchReceived) = CHUNK_BATCH_RECEIVED,
     ClientCommand(ClientCommand) = CLIENT_COMMAND,
     ClientInformation(ClientInformation) = CLIENT_INFORMATION,
@@ -2317,9 +2332,11 @@ packet_enum!(Serverbound, crate::ids::play::serverbound {
     ContainerSlotStateChanged(ContainerSlotStateChanged) = CONTAINER_SLOT_STATE_CHANGED,
     Punch(Empty) = PUNCH,
     ResourcePack(ResourcePackResponse) = RESOURCE_PACK,
+    SelectBundleItem(SelectBundleItem) = BUNDLE_ITEM_SELECTED,
     SelectTrade(SelectTrade) = SELECT_TRADE,
     SetBeacon(SetBeacon) = SET_BEACON,
     SetCarriedItem(SetCarriedItem) = SET_CARRIED_ITEM,
+    SetCommandBlock(SetCommandBlock) = SET_COMMAND_BLOCK,
     SetCreativeModeSlot(SetCreativeModeSlot) = SET_CREATIVE_MODE_SLOT,
     SignUpdate(SignUpdate) = SIGN_UPDATE,
     UseItem(UseItem) = USE_ITEM,
diff --git a/crates/horizon-protocol/src/packets/recipes.rs b/crates/horizon-protocol/src/packets/recipes.rs
index c289b8943..dcbe5ffa0 100644
--- a/crates/horizon-protocol/src/packets/recipes.rs
+++ b/crates/horizon-protocol/src/packets/recipes.rs
@@ -500,6 +500,33 @@ impl Codec<RecipeBookSettings> for RecipeBookSettings {
     }
 }
 
+/// ServerboundRecipeBookChangeSettingsPacket: the active book's open and
+/// filtering flags, with its `RecipeBookType` ordinal as a VarInt.
+#[derive(Clone, Debug, PartialEq)]
+pub struct RecipeBookChangeSettings {
+    pub book_type: i32,
+    pub open: bool,
+    pub filtering: bool,
+}
+impl Codec<RecipeBookChangeSettings> for RecipeBookChangeSettings {
+    fn read(r: &mut Reader) -> Result<Self> {
+        let book_type = r.varint()?;
+        if !(0..4).contains(&book_type) {
+            return Err(crate::Error::new("invalid recipe book type"));
+        }
+        Ok(Self {
+            book_type,
+            open: r.bool()?,
+            filtering: r.bool()?,
+        })
+    }
+    fn write(v: &Self, w: &mut Writer) {
+        w.varint(v.book_type);
+        w.bool(v.open);
+        w.bool(v.filtering);
+    }
+}
+
 /// ClientboundPlaceGhostRecipePacket: the recipe to show faded in a menu
 /// whose items were missing.
 #[derive(Clone, Debug, PartialEq)]
diff --git a/crates/horizon-threads/Cargo.toml b/crates/horizon-threads/Cargo.toml
index d43b3e4fc..67b3c20da 100644
--- a/crates/horizon-threads/Cargo.toml
+++ b/crates/horizon-threads/Cargo.toml
@@ -10,7 +10,7 @@ description = "Scheduling hints for the game's threads: the OS calls the crates
 libc = "0.2"
 
 [target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.61", features = ["Win32_System_Threading"] }
+windows-sys = { version = "0.61", features = ["Win32_System_Threading", "Win32_System_WindowsProgramming"] }
 
 [lints]
 workspace = true
diff --git a/crates/horizon-threads/src/lib.rs b/crates/horizon-threads/src/lib.rs
index 90c8d128e..01e815e8b 100644
--- a/crates/horizon-threads/src/lib.rs
+++ b/crates/horizon-threads/src/lib.rs
@@ -41,6 +41,43 @@ fn favour() -> bool {
     false
 }
 
+/// The CPU time the calling thread has used, where only an OS call gives it
+/// precisely. Windows counts it exactly only in cycles of the time-stamp
+/// counter (`QueryThreadCycleTime`; `GetThreadTimes` moves in scheduler ticks
+/// of ~15.6 ms), so the counter's rate is measured once against the wall
+/// clock and cycles convert to time. `None` elsewhere: unix callers read
+/// `CLOCK_THREAD_CPUTIME_ID` themselves.
+#[cfg(all(windows, target_arch = "x86_64"))]
+pub fn thread_cpu() -> Option<std::time::Duration> {
+    use std::{
+        sync::OnceLock,
+        time::{Duration, Instant},
+    };
+    use windows_sys::Win32::System::{
+        Threading::GetCurrentThread, WindowsProgramming::QueryThreadCycleTime,
+    };
+    // Time-stamp counter cycles per nanosecond.
+    static RATE: OnceLock<f64> = OnceLock::new();
+    let rate = *RATE.get_or_init(|| {
+        // SAFETY: RDTSC has no preconditions on x86_64.
+        let tsc = || unsafe { core::arch::x86_64::_rdtsc() };
+        let (wall, start) = (Instant::now(), tsc());
+        std::thread::sleep(Duration::from_millis(20));
+        (tsc() - start) as f64 / wall.elapsed().as_nanos() as f64
+    });
+    let mut cycles = 0;
+    // SAFETY: GetCurrentThread's pseudo handle needs no closing; a valid out pointer.
+    if unsafe { QueryThreadCycleTime(GetCurrentThread(), &mut cycles) } == 0 {
+        return None;
+    }
+    Some(Duration::from_nanos((cycles as f64 / rate) as u64))
+}
+
+#[cfg(not(all(windows, target_arch = "x86_64")))]
+pub fn thread_cpu() -> Option<std::time::Duration> {
+    None
+}
+
 /// Set once as the game starts, before its helper threads do: they then go
 /// behind the server thread and the render thread (`behind_server`).
 static HELPERS_BEHIND: AtomicBool = AtomicBool::new(false);
@@ -126,6 +163,70 @@ fn idle() -> bool {
     false
 }
 
+/// How many stop requests (Ctrl-C, SIGTERM, SIGHUP) arrived since `catch_stop_signals`.
+pub fn stop_requests() -> u32 {
+    STOP_REQUESTS.load(std::sync::atomic::Ordering::SeqCst)
+}
+
+static STOP_REQUESTS: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+
+/// Count stop requests from outside instead of dying on them: vanilla's "Client Shutdown Thread"
+/// (`Main.java`) halts the integrated server when the JVM shuts down, and the JVM does that on
+/// these signals, so a killed game still saves. The caller's event loop turns the first request
+/// into a normal quit; a second one (the save is stuck) ends the process at once.
+#[cfg(any(target_vendor = "apple", target_os = "linux", target_os = "android"))]
+pub fn catch_stop_signals() {
+    extern "C" fn handle(_: libc::c_int) {
+        if STOP_REQUESTS.fetch_add(1, Ordering::SeqCst) >= 1 {
+            // SAFETY: _exit is async-signal-safe; 130 is the shell's code for a Ctrl-C death.
+            unsafe { libc::_exit(130) }
+        }
+    }
+    let handler = handle as extern "C" fn(libc::c_int);
+    for signal in [libc::SIGINT, libc::SIGTERM, libc::SIGHUP] {
+        // SAFETY: the handler only touches an atomic and calls _exit, both async-signal-safe.
+        unsafe {
+            libc::signal(signal, handler as libc::sighandler_t);
+        }
+    }
+}
+
+/// Windows and the other systems keep their default: a closed window is a `CloseRequested`.
+#[cfg(not(any(target_vendor = "apple", target_os = "linux", target_os = "android")))]
+pub fn catch_stop_signals() {}
+
+/// Give back to the OS the memory the allocator holds free, after something
+/// large was dropped: glibc keeps freed pages in the arena of the thread that
+/// allocated them, and macOS in its zones until memory runs short. Nothing
+/// elsewhere.
+pub fn release_free_memory() {
+    release();
+}
+
+#[cfg(all(target_os = "linux", target_env = "gnu"))]
+fn release() {
+    // SAFETY: returns free heap pages of every arena to the OS; no live
+    // allocation moves.
+    unsafe {
+        libc::malloc_trim(0);
+    }
+}
+
+#[cfg(target_vendor = "apple")]
+fn release() {
+    unsafe extern "C" {
+        fn malloc_zone_pressure_relief(zone: *mut std::ffi::c_void, goal: usize) -> usize;
+    }
+    // SAFETY: a null zone means every zone and a goal of 0 as much as it can;
+    // it frees only pages no allocation uses.
+    unsafe {
+        malloc_zone_pressure_relief(std::ptr::null_mut(), 0);
+    }
+}
+
+#[cfg(not(any(all(target_os = "linux", target_env = "gnu"), target_vendor = "apple")))]
+fn release() {}
+
 #[cfg(test)]
 mod tests {
     /// The hint holds on the platforms that take it.
diff --git a/crates/horizon-world/examples/probe/main.rs b/crates/horizon-world/examples/probe/main.rs
index b87e5620a..56dbc8843 100644
--- a/crates/horizon-world/examples/probe/main.rs
+++ b/crates/horizon-world/examples/probe/main.rs
@@ -137,6 +137,7 @@ mod movement_support_fixture;
 mod object_open_map_fixture;
 mod object_open_set_fixture;
 mod piston_movement_fixture;
+mod piston_push_fixture;
 mod piston_shape_fixture;
 mod placement_fixture;
 mod player_equipment_fixture;
@@ -309,6 +310,7 @@ probes! {
     object_open_map_fixture,
     object_open_set_fixture,
     piston_movement_fixture,
+    piston_push_fixture,
     piston_shape_fixture,
     placement_fixture,
     player_equipment_fixture,
diff --git a/crates/horizon-world/examples/probe/piston_push_fixture.rs b/crates/horizon-world/examples/probe/piston_push_fixture.rs
new file mode 100644
index 000000000..1d40cd610
--- /dev/null
+++ b/crates/horizon-world/examples/probe/piston_push_fixture.rs
@@ -0,0 +1,163 @@
+//! The moving-piston push maths against the real game: `PistonMath.getMovementArea`,
+//! `moveByPositionAndProgress`, `getMovement`, the `moveCollidedEntities` loop
+//! over the block's own boxes, and `moveStuckEntities`' box with
+//! `matchesStickyCritera`.
+use crate::support::common::f64_hex;
+use horizon_core::{
+    geometry::{Aabb, Direction, Vec3},
+    position::BlockPos,
+};
+use horizon_world::{level::data::PushReaction, piston_push, piston_shape::MovingPistonState};
+use serde_json::Value;
+use std::{
+    fs,
+    io::{self, BufWriter, Write},
+    path::Path,
+};
+
+fn number(v: &Value) -> f64 {
+    f64::from_bits(u64::from_str_radix(v.as_str().unwrap(), 16).unwrap())
+}
+
+fn float(v: &Value) -> f32 {
+    f32::from_bits(u32::from_str_radix(v.as_str().unwrap(), 16).unwrap())
+}
+
+fn aabb(v: &Value) -> Aabb {
+    let a = v.as_array().unwrap();
+    Aabb::new(
+        Vec3::new(number(&a[0]), number(&a[1]), number(&a[2])),
+        Vec3::new(number(&a[3]), number(&a[4]), number(&a[5])),
+    )
+}
+
+fn direction(index: i64) -> Direction {
+    Direction::ALL[index.rem_euclid(6) as usize]
+}
+
+fn reaction(index: i64) -> PushReaction {
+    match index.rem_euclid(5) {
+        0 => PushReaction::PushPull,
+        1 => PushReaction::Push,
+        2 => PushReaction::Popped,
+        3 => PushReaction::Immoveable,
+        _ => PushReaction::IgnoreEntity,
+    }
+}
+
+fn line(out: &mut impl Write, name: &str, b: Aabb) -> io::Result<()> {
+    let (min, max) = (b.min_position(), b.max_position());
+    writeln!(
+        out,
+        "{name} {} {} {} {} {} {}",
+        f64_hex(min.x),
+        f64_hex(min.y),
+        f64_hex(min.z),
+        f64_hex(max.x),
+        f64_hex(max.y),
+        f64_hex(max.z)
+    )
+}
+
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let arg = crate::args().nth(1).expect("private fixture directory");
+    let dir = Path::new(&arg);
+    let mut out = BufWriter::new(fs::File::create(dir.join("rust.txt"))?);
+    for text in fs::read_to_string(dir.join("inputs.txt"))?.lines() {
+        let f: Value = serde_json::from_str(text)?;
+        let p = &f["pos"];
+        let pos = BlockPos::new(
+            p[0].as_i64().unwrap() as i32,
+            p[1].as_i64().unwrap() as i32,
+            p[2].as_i64().unwrap() as i32,
+        );
+        let progress = float(&f["progress"]);
+        let piston = MovingPistonState {
+            moved_state: horizon_world::registry::BlockStateId(0),
+            direction: direction(f["direction"].as_i64().unwrap()),
+            extending: f["extending"].as_bool().unwrap(),
+            source: f["source"].as_bool().unwrap(),
+            progress,
+            previous_progress: progress,
+        };
+        let new_progress = float(&f["new_progress"]);
+        let delta_progress = f64::from(new_progress - progress);
+        let movement = piston.movement_direction();
+        let block_box = aabb(&f["block_box"]);
+        let entity = aabb(&f["entity"]);
+        let movement_box = aabb(&f["movement_box"]);
+
+        writeln!(
+            out,
+            "extended {:08x}",
+            piston_push::extended_progress(piston, progress).to_bits()
+        )?;
+        let origin = piston_push::move_by_position_and_progress(pos, block_box, piston);
+        line(&mut out, "origin", origin)?;
+        line(
+            &mut out,
+            "area",
+            piston_push::movement_area(block_box, movement, delta_progress),
+        )?;
+        for (name, face) in [
+            ("east", Direction::East),
+            ("west", Direction::West),
+            ("up", Direction::Up),
+            ("down", Direction::Down),
+            ("south", Direction::South),
+            ("north", Direction::North),
+        ] {
+            writeln!(
+                out,
+                "movement {name} {}",
+                f64_hex(piston_push::get_movement(movement_box, face, entity))
+            )?;
+        }
+
+        // `moveCollidedEntities`' loop: the furthest box reaches into the
+        // entity, capped at the progress delta, plus the push offset.
+        let boxes: Vec<Aabb> = f["boxes"].as_array().unwrap().iter().map(aabb).collect();
+        let mut delta: f64 = 0.0;
+        let mut capped = false;
+        for block in &boxes {
+            let moving = piston_push::movement_area(
+                piston_push::move_by_position_and_progress(pos, *block, piston),
+                movement,
+                delta_progress,
+            );
+            if moving.intersects(entity) {
+                delta = delta.max(piston_push::get_movement(moving, movement, entity));
+                if delta >= delta_progress {
+                    capped = true;
+                    break;
+                }
+            }
+        }
+        let collided = if delta <= 0.0 {
+            0.0
+        } else {
+            delta.min(delta_progress) + piston_push::PUSH_OFFSET
+        };
+        writeln!(out, "collided {} {capped}", f64_hex(collided))?;
+        line(
+            &mut out,
+            "search",
+            piston_push::movement_search_area(origin, movement, delta_progress),
+        )?;
+        let sticky = piston_push::sticky_area(pos, piston, number(&f["sticky_top"]));
+        line(&mut out, "sticky", sticky)?;
+        writeln!(
+            out,
+            "matches {}",
+            piston_push::matches_sticky_criteria(
+                sticky,
+                reaction(f["reaction"].as_i64().unwrap()),
+                f["on_ground"].as_bool().unwrap(),
+                f["supported"].as_bool().unwrap(),
+                Vec3::new(number(&f["entity_x"]), 0.0, number(&f["entity_z"])),
+            )
+        )?;
+    }
+    out.flush()?;
+    Ok(())
+}
diff --git a/crates/horizon-world/src/level/hooks.rs b/crates/horizon-world/src/level/hooks.rs
index 7f9e8d19a..f716449f5 100644
--- a/crates/horizon-world/src/level/hooks.rs
+++ b/crates/horizon-world/src/level/hooks.rs
@@ -447,6 +447,13 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
             if !b.table.bool(state, b.props.powered) {
                 self.detector_rail_check_pressed(pos, state);
             }
+        } else if data.is(Class::Button) {
+            // ButtonBlock.entityInside: a wooden button an arrow is inside.
+            if data.set_type.as_ref().is_some_and(|s| s.arrows)
+                && !b.table.bool(state, b.props.powered)
+            {
+                self.button_check_pressed(pos, state);
+            }
         } else if data.is(Class::TripWire)
             && !b.table.bool(state, b.props.powered)
             && !self.ticks.has_block_tick(pos, b.block(state))
diff --git a/crates/horizon-world/src/level/interact.rs b/crates/horizon-world/src/level/interact.rs
index 7b2195c34..8f17ba1cc 100644
--- a/crates/horizon-world/src/level/interact.rs
+++ b/crates/horizon-world/src/level/interact.rs
@@ -195,6 +195,7 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
                     let next = table.cycle(state, p.inverted);
                     self.set_block(pos, next, 2);
                     self.game_event(pos, "minecraft:block_change");
+                    self.daylight_detector_update_signal(pos, next);
                     Success
                 }
                 Class::Cake => {
@@ -227,19 +228,7 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
                     if table.int(state, p.level) != 8 {
                         return Pass;
                     }
-                    self.player_effect(
-                        pos,
-                        state,
-                        PlayerEffect::DropItem("minecraft:bone_meal".into()),
-                    );
-                    self.set_block_and_update(pos, table.set_int(state, p.level, 0));
-                    self.game_event(pos, "minecraft:block_change");
-                    self.emit(LevelEvent::Sound {
-                        pos,
-                        sound: "minecraft:block.composter.empty".into(),
-                        volume: 1.0,
-                        pitch: 1.0,
-                    });
+                    self.composter_extract_produce(pos, state);
                     Success
                 }
                 Class::CaveVines | Class::CaveVinesPlant => {
@@ -435,6 +424,25 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
         InteractionResult::Success
     }
 
+    /// `ComposterBlock.extractProduce`: the bone meal pops out, the composter
+    /// empties and its sound plays.
+    fn composter_extract_produce(&mut self, pos: BlockPos, state: BlockStateId) {
+        let b = self.b;
+        self.player_effect(
+            pos,
+            state,
+            PlayerEffect::DropItem("minecraft:bone_meal".into()),
+        );
+        self.set_block_and_update(pos, b.table.set_int(state, b.props.level, 0));
+        self.game_event(pos, "minecraft:block_change");
+        self.emit(LevelEvent::Sound {
+            pos,
+            sound: "minecraft:block.composter.empty".into(),
+            volume: 1.0,
+            pitch: 1.0,
+        });
+    }
+
     /// `ComposterBlock.addLayer` once its `compostable` provider gave
     /// `layers`: the new state (the old one when no layer is added).
     fn composter_add_layer(&mut self, pos: BlockPos, layers: i32) -> BlockStateId {
@@ -499,6 +507,44 @@ impl Behaviours {
         next
     }
 
+    /// `ComposterBlock.addLayer` without level event 1500, for a villager
+    /// that composts several items and sends the event once at the end
+    /// (`WorkAtComposter.compostItems`). The new state.
+    pub fn composter_layer<L: LevelAccess + ?Sized>(
+        &self,
+        level: &mut L,
+        ticks: &mut Ticks,
+        pos: BlockPos,
+        layers: i32,
+    ) -> BlockStateId {
+        self.sim(level, ticks).composter_add_layer(pos, layers)
+    }
+
+    /// `ComposterBlock.extractProduce` by a villager (`WorkAtComposter`).
+    pub fn composter_extract<L: LevelAccess + ?Sized>(
+        &self,
+        level: &mut L,
+        ticks: &mut Ticks,
+        pos: BlockPos,
+    ) {
+        let mut sim = self.sim(level, ticks);
+        let state = sim.state(pos);
+        sim.composter_extract_produce(pos, state);
+    }
+
+    /// Level event 1500 (`WorkAtComposter.spawnComposterFillEffects`): data 1
+    /// when the composter's state changed.
+    pub fn composter_fill_effects<L: LevelAccess + ?Sized>(
+        &self,
+        level: &mut L,
+        ticks: &mut Ticks,
+        pos: BlockPos,
+        changed: bool,
+    ) {
+        self.sim(level, ticks)
+            .level_event(1500, pos, i32::from(changed));
+    }
+
     /// `ComposterBlock.empty`: the hopper output container took the bone meal.
     pub fn composter_empty<L: LevelAccess + ?Sized>(
         &self,
@@ -513,20 +559,26 @@ impl Behaviours {
         sim.game_event_state(pos, "minecraft:block_change", next);
     }
 
-    /// The state change of `RedStoneOreBlock.attack` when mining begins.
+    /// `BlockBehaviour.attack` when mining begins: `RedStoneOreBlock.attack`
+    /// lights the ore, `NoteBlock.attack` plays the note. True for a note
+    /// block, whose player also earns the `play_noteblock` statistic.
     pub fn attack_block<L: LevelAccess + ?Sized>(
         &self,
         level: &mut L,
         ticks: &mut Ticks,
         pos: BlockPos,
-    ) {
+    ) -> bool {
         let mut sim = self.sim(level, ticks);
         let state = sim.state(pos);
-        if self.data(state).chain.contains(&Class::RedStoneOre)
-            && !self.table.bool(state, self.props.lit)
-        {
+        let chain = &self.data(state).chain;
+        if chain.contains(&Class::Note) {
+            sim.note_play(pos, state);
+            return true;
+        }
+        if chain.contains(&Class::RedStoneOre) && !self.table.bool(state, self.props.lit) {
             sim.set_block_and_update(pos, self.table.set_bool(state, self.props.lit, true));
         }
+        false
     }
 
     /// `BlockState.useWithoutItem` for a right-click on `pos` (hit face and
@@ -595,6 +647,25 @@ impl Behaviours {
         if self.data(state).chain.contains(&Class::CopperGolemStatue) {
             return self.turn_statue(level, ticks, pos, state, item);
         }
+        // NoteBlock.useItemOn: a mob head on the top face is placed, not tuned
+        // (`#minecraft:noteblock_top_instruments`).
+        if face == Direction::Up
+            && self.data(state).chain.contains(&Class::Note)
+            && item.is_some_and(|i| {
+                matches!(
+                    i,
+                    "minecraft:zombie_head"
+                        | "minecraft:skeleton_skull"
+                        | "minecraft:creeper_head"
+                        | "minecraft:dragon_head"
+                        | "minecraft:wither_skeleton_skull"
+                        | "minecraft:piglin_head"
+                        | "minecraft:player_head"
+                )
+            })
+        {
+            return InteractionResult::Pass;
+        }
         self.use_without_item(level, ticks, pos, face, hit, player)
     }
 
diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs
index c81bdf369..0a8e160cd 100644
--- a/crates/horizon-world/src/level/mod.rs
+++ b/crates/horizon-world/src/level/mod.rs
@@ -209,6 +209,9 @@ pub enum EntityQuery {
     Mobs,
     /// Minecarts only (detector rails).
     Minecart,
+    /// Arrows only (`AbstractArrow`, thrown tridents included): the entities
+    /// a wooden button senses.
+    Arrows,
 }
 
 /// Side effects reported to the caller, in vanilla call order.
@@ -328,6 +331,10 @@ pub trait LevelAccess {
     fn sky_darken(&self) -> i32 {
         0
     }
+    /// `EnvironmentAttributes.SUN_ANGLE` at `pos`, in degrees (0 at noon).
+    fn sun_angle(&self, _pos: BlockPos) -> f32 {
+        0.0
+    }
     fn is_raining(&self) -> bool {
         false
     }
@@ -763,6 +770,24 @@ impl Behaviours {
     ) {
         self.sim(level, ticks).entity_inside(pos);
     }
+    /// `DaylightDetectorBlock.tickEntity` of the daylight detector at `pos`:
+    /// its signal follows the sky every 20 game ticks. The detector's ticker
+    /// exists only where the dimension has sky light.
+    pub fn tick_daylight_detector<L: LevelAccess + ?Sized>(
+        &self,
+        level: &mut L,
+        ticks: &mut Ticks,
+        pos: BlockPos,
+    ) {
+        if level.dimension() == Dimension::Nether || level.game_time() % 20 != 0 {
+            return;
+        }
+        let mut sim = self.sim(level, ticks);
+        let state = sim.state(pos);
+        if sim.b.data(state).is(classes::Class::DaylightDetector) {
+            sim.daylight_detector_update_signal(pos, state);
+        }
+    }
     /// `BigDripleafBlock.entityInside` for an entity whose box is inside
     /// `pos`: whether it is on the ground and its feet's y (`canEntityTilt`).
     pub fn entity_on_big_dripleaf<L: LevelAccess + ?Sized>(
@@ -793,6 +818,22 @@ impl Behaviours {
     ) -> i32 {
         self.sim(level, ticks).best_neighbor_signal(pos)
     }
+    /// `BlockState.onProjectileHit` of a target block (`TargetBlock`) hit by
+    /// a projectile at `location` on the face with normal `face`; `arrow`
+    /// for an `AbstractArrow`. Returns the output strength, or None when the
+    /// block at `pos` is not a target block.
+    pub fn target_projectile_hit<L: LevelAccess + ?Sized>(
+        &self,
+        level: &mut L,
+        ticks: &mut Ticks,
+        pos: BlockPos,
+        location: [f64; 3],
+        face: [i32; 3],
+        arrow: bool,
+    ) -> Option<i32> {
+        self.sim(level, ticks)
+            .target_projectile_hit(pos, location, face, arrow)
+    }
 }
 
 /// One mutable view used by the ported behaviour code.
diff --git a/crates/horizon-world/src/level/pistons.rs b/crates/horizon-world/src/level/pistons.rs
index 45e469efd..70e8aa32a 100644
--- a/crates/horizon-world/src/level/pistons.rs
+++ b/crates/horizon-world/src/level/pistons.rs
@@ -182,7 +182,9 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
             self.neighbor_changed_at(pos, block);
         }
     }
-    /// `PistonMovingBlockEntity.tick` (entity pushing excluded).
+    /// `PistonMovingBlockEntity.tick`. A piston that is still moving reports
+    /// the push `moveCollidedEntities` would do at its new progress; the caller
+    /// moves the entities, because `Ticks` has none (`piston_pushes`).
     fn moving_piston_tick(&mut self, pos: BlockPos) {
         let Some(mut piston) = self.moving_piston(pos) else {
             return;
@@ -227,14 +229,20 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
                 }
             }
         } else {
-            piston.progress = (piston.progress + 0.5).min(1.0);
-            if let Some(entry) = self
+            // moveCollidedEntities and moveStuckEntities run with the new
+            // progress but read the old one off the entity (their delta),
+            // so the push carries the piston as it was before the advance.
+            let old = piston;
+            let new_progress = (old.progress + 0.5).min(1.0);
+            let current = self
                 .ticks
                 .moving_pistons
                 .iter_mut()
-                .find(|(p, _)| *p == pos)
-            {
+                .find(|(p, _)| *p == pos);
+            if let Some(entry) = current {
+                piston.progress = new_progress;
                 entry.1 = piston;
+                self.ticks.piston_pushes.push((pos, old, new_progress));
             }
         }
     }
diff --git a/crates/horizon-world/src/level/redstone.rs b/crates/horizon-world/src/level/redstone.rs
index 92f9059e5..42ba42634 100644
--- a/crates/horizon-world/src/level/redstone.rs
+++ b/crates/horizon-world/src/level/redstone.rs
@@ -11,7 +11,10 @@ use super::{
 };
 use crate::registry::BlockStateId;
 use horizon_core::{
-    geometry::Direction, position::BlockPos, random::RandomSource, ticks::TickPriority,
+    geometry::{Direction, trig},
+    position::BlockPos,
+    random::RandomSource,
+    ticks::TickPriority,
 };
 
 const SIGNAL_ORDER: [Direction; 6] = [
@@ -879,18 +882,109 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
         }
         self.game_event(pos, "minecraft:block_activate");
     }
-    /// `ButtonBlock.checkPressed` with no arrows present.
+    /// `ButtonBlock.tick`.
     pub(crate) fn button_tick(&mut self, pos: BlockPos, state: BlockStateId) {
         let b = self.b;
-        if !b.table.bool(state, b.props.powered) {
-            return;
+        if b.table.bool(state, b.props.powered) {
+            self.button_check_pressed(pos, state);
         }
-        self.set_block_and_update(pos, b.table.set_bool(state, b.props.powered, false));
-        self.attached_update_neighbours(pos, state);
-        if let Some(set) = b.data(state).set_type.clone() {
-            self.sound(pos, &set.button_off, 1.0, 1.0);
+    }
+    /// `ButtonBlock.checkPressed`: a button whose type allows arrows is
+    /// pressed while an arrow is inside its shape, and stays pressed (the
+    /// release is scheduled again) as long as one is.
+    pub(crate) fn button_check_pressed(&mut self, pos: BlockPos, state: BlockStateId) {
+        let b = self.b;
+        let data = b.data(state);
+        let should_be_pressed = data.set_type.as_ref().is_some_and(|s| s.arrows)
+            && self
+                .level
+                .count_entities(self.button_bounds(pos, state), super::EntityQuery::Arrows)
+                > 0;
+        let was_pressed = b.table.bool(state, b.props.powered);
+        if should_be_pressed != was_pressed {
+            self.set_block_and_update(
+                pos,
+                b.table.set_bool(state, b.props.powered, should_be_pressed),
+            );
+            self.attached_update_neighbours(pos, state);
+            if let Some(set) = data.set_type.clone() {
+                let sound = if should_be_pressed {
+                    &set.button_on
+                } else {
+                    &set.button_off
+                };
+                self.sound(pos, sound, 1.0, 1.0);
+            }
+            self.game_event(
+                pos,
+                if should_be_pressed {
+                    "minecraft:block_activate"
+                } else {
+                    "minecraft:block_deactivate"
+                },
+            );
+        }
+        if should_be_pressed {
+            self.schedule_tick(pos, b.block(state), data.ticks_to_stay_pressed);
+        }
+    }
+    /// `ButtonBlock.getShape(...).bounds().move(pos)`: a 6 by 4 plate on the
+    /// face it is attached to, 2 pixels thick (1 when pressed).
+    fn button_bounds(&self, pos: BlockPos, state: BlockStateId) -> horizon_core::geometry::Aabb {
+        use horizon_core::geometry::{Aabb, Vec3};
+        let b = self.b;
+        let thickness = if b.table.bool(state, b.props.powered) {
+            1.0 / 16.0
+        } else {
+            2.0 / 16.0
+        };
+        let attached = self.face_attached_connected(state).opposite().normal();
+        let thick = attached.iter().position(|&n| n != 0).unwrap_or(1);
+        // The 6 pixel side lies across the button's facing.
+        let wide = if b.facing(state).normal()[2] != 0 {
+            0
+        } else {
+            2
+        };
+        let tall = 3 - thick - wide;
+        let (mut lo, mut hi) = ([0.0; 3], [1.0; 3]);
+        if attached[thick] > 0 {
+            lo[thick] = 1.0 - thickness;
+        } else {
+            hi[thick] = thickness;
+        }
+        (lo[wide], hi[wide]) = (5.0 / 16.0, 11.0 / 16.0);
+        (lo[tall], hi[tall]) = (6.0 / 16.0, 10.0 / 16.0);
+        let origin = [f64::from(pos.x), f64::from(pos.y), f64::from(pos.z)];
+        Aabb::new(
+            Vec3::new(origin[0] + lo[0], origin[1] + lo[1], origin[2] + lo[2]),
+            Vec3::new(origin[0] + hi[0], origin[1] + hi[1], origin[2] + hi[2]),
+        )
+    }
+    /// `DaylightDetectorBlock.updateSignalStrength`: the effective sky light
+    /// at the detector, shaped by the sun's angle (or inverted), as its
+    /// power.
+    pub(crate) fn daylight_detector_update_signal(&mut self, pos: BlockPos, state: BlockStateId) {
+        let b = self.b;
+        let mut target = (self.level.sky_light(pos) - self.level.sky_darken()).max(0);
+        if b.table.bool(state, b.props.inverted) {
+            target = 15 - target;
+        } else if target > 0 {
+            let mut sun_angle = self.level.sun_angle(pos) * trig::DEG_TO_RAD;
+            let offset = if sun_angle < std::f32::consts::PI {
+                0.0
+            } else {
+                std::f32::consts::TAU
+            };
+            sun_angle += (offset - sun_angle) * 0.2;
+            // Math.round(float).
+            let scaled = target as f32 * trig::cos(f64::from(sun_angle));
+            target = (f64::from(scaled) + 0.5).floor() as i32;
+        }
+        let target = target.clamp(0, 15);
+        if b.table.int(state, b.props.power) != target {
+            self.set_block_and_update(pos, b.table.set_int(state, b.props.power, target));
         }
-        self.game_event(pos, "minecraft:block_deactivate");
     }
     /// `LeverBlock.pull`.
     pub(crate) fn lever_pull(&mut self, pos: BlockPos, state: BlockStateId) {
@@ -1080,7 +1174,8 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
             self.game_event(pos, "minecraft:note_block_play");
         }
     }
-    /// `NoteBlock.triggerEvent`: the note's sound.
+    /// `NoteBlock.triggerEvent`: the note's particle (tunable instruments)
+    /// and sound.
     pub(crate) fn note_trigger_event(&mut self, pos: BlockPos, state: BlockStateId) {
         let b = self.b;
         let instrument = b.table.text(state, b.props.instrument).to_owned();
@@ -1092,6 +1187,12 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
         let pitch = if mob_head {
             1.0
         } else {
+            // `isTunable`: the client adds the NOTE particle above the block.
+            self.emit(LevelEvent::BlockEvent {
+                pos,
+                state,
+                kind: "note_particle",
+            });
             horizon_core::jmath::pow(2.0, f64::from(note - 12) / 12.0) as f32
         };
         let sound = match instrument.as_str() {
@@ -1187,6 +1288,43 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
             self.set_block(pos, next, 2);
         }
     }
+    /// `TargetBlock.onProjectileHit` for a projectile that hit `face` of the
+    /// block at `pos` at `location`: the output power from how near the
+    /// face's centre it landed (1 to 15), reset after 20 ticks for an arrow
+    /// and 8 for anything else, unless a reset is already scheduled. None
+    /// when the block is not a target block, else the strength.
+    pub(crate) fn target_projectile_hit(
+        &mut self,
+        pos: BlockPos,
+        location: [f64; 3],
+        face: [i32; 3],
+        arrow: bool,
+    ) -> Option<i32> {
+        let b = self.b;
+        let state = self.state(pos);
+        if !b.data(state).is(Class::Target) {
+            return None;
+        }
+        // `getRedstoneStrength`: the distance from the centre along the
+        // face's two other axes (Mth.frac of the location, minus a half).
+        let off = |v: f64| (v - v.floor() - 0.5).abs();
+        let [dx, dy, dz] = [off(location[0]), off(location[1]), off(location[2])];
+        let distance = if face[1] != 0 {
+            dx.max(dz)
+        } else if face[2] != 0 {
+            dx.max(dy)
+        } else {
+            dy.max(dz)
+        };
+        let strength = ((15.0 * ((0.5 - distance) / 0.5).clamp(0.0, 1.0)).ceil() as i32).max(1);
+        let block = b.block(state);
+        if !self.ticks.has_block_tick(pos, block) {
+            // `setOutputPower`.
+            self.set_block_and_update(pos, b.table.set_int(state, b.props.power, strength));
+            self.schedule_tick(pos, block, if arrow { 20 } else { 8 });
+        }
+        Some(strength)
+    }
 }
 
 /// Order `positions` as a `java.util.HashSet<BlockPos>` of capacity 16 would
diff --git a/crates/horizon-world/src/level/tick.rs b/crates/horizon-world/src/level/tick.rs
index 25e2a19d3..51b6b8083 100644
--- a/crates/horizon-world/src/level/tick.rs
+++ b/crates/horizon-world/src/level/tick.rs
@@ -1478,6 +1478,80 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
         let block = b.table.block_by_name(&format!("minecraft:{next}"))?;
         Some(b.table.with_properties_of(block, state))
     }
+    /// `WeatheringCopper.getPrevious` (and `getFirst` by repeating it) by
+    /// registry naming: the block one oxidation step back.
+    fn copper_previous_name(path: &str) -> Option<String> {
+        if let Some(rest) = path.strip_prefix("oxidized_") {
+            Some(format!("weathered_{rest}"))
+        } else if let Some(rest) = path.strip_prefix("weathered_") {
+            Some(format!("exposed_{rest}"))
+        } else {
+            path.strip_prefix("exposed_").map(|rest| {
+                if rest == "copper" {
+                    "copper_block".to_owned()
+                } else {
+                    rest.to_owned()
+                }
+            })
+        }
+    }
+    fn copper_stepped(&self, state: BlockStateId, all_the_way: bool) -> Option<BlockStateId> {
+        let b = self.b;
+        let name = &*b.table.info(b.block(state)).name;
+        let mut path = Self::copper_previous_name(name.strip_prefix("minecraft:")?)?;
+        while all_the_way && let Some(earlier) = Self::copper_previous_name(&path) {
+            path = earlier;
+        }
+        let block = b.table.block_by_name(&format!("minecraft:{path}"))?;
+        Some(b.table.with_properties_of(block, state))
+    }
+    /// `LightningBolt.clearCopperOnLightningStrike`: the struck copper goes
+    /// back to unoxidized, then 3 to 5 random walks of up to 8 steps each
+    /// scrape one step of oxidation off the weathering copper they land on.
+    /// A waxed block is left as it is but still starts the walks.
+    pub(crate) fn lightning_clear_copper(&mut self, struck: BlockPos) {
+        let b = self.b;
+        let state = self.state(struck);
+        let weathering = b
+            .data(state)
+            .implements(super::classes::Interface::WeatheringCopper);
+        let waxed = b.table.name(state).starts_with("minecraft:waxed_");
+        if !(weathering || waxed) {
+            return;
+        }
+        if weathering && let Some(first) = self.copper_stepped(state, true) {
+            self.set_block_and_update(struck, first);
+        }
+        for _ in 0..self.rand_int(3) + 3 {
+            let mut at = struck;
+            for _ in 0..self.rand_int(8) + 1 {
+                // randomStepCleaningCopper: up to 10 random blocks in the
+                // 3x3x3 cube around the walk's position.
+                let mut next = None;
+                for _ in 0..10 {
+                    let x = at.x - 1 + self.rand_int(3);
+                    let y = at.y - 1 + self.rand_int(3);
+                    let z = at.z - 1 + self.rand_int(3);
+                    let candidate = BlockPos::new(x, y, z);
+                    let state = self.state(candidate);
+                    if b.data(state)
+                        .implements(super::classes::Interface::WeatheringCopper)
+                    {
+                        if let Some(previous) = self.copper_stepped(state, false) {
+                            self.set_block_and_update(candidate, previous);
+                        }
+                        self.level_event(3002, candidate, -1);
+                        next = Some(candidate);
+                        break;
+                    }
+                }
+                match next {
+                    Some(p) => at = p,
+                    None => break,
+                }
+            }
+        }
+    }
 }
 
 /// `Biome.Precipitation` at a position.
@@ -1661,6 +1735,15 @@ impl Behaviours {
     ) {
         self.sim(level, ticks).random_tick_at(pos);
     }
+    /// `LightningBolt.clearCopperOnLightningStrike` for the block at `struck`.
+    pub fn lightning_clear_copper<L: LevelAccess + ?Sized>(
+        &self,
+        level: &mut L,
+        ticks: &mut Ticks,
+        struck: BlockPos,
+    ) {
+        self.sim(level, ticks).lightning_clear_copper(struck);
+    }
     /// Run one scheduled block tick at `pos` immediately (no queue check).
     pub fn scheduled_block_tick<L: LevelAccess + ?Sized>(
         &self,
diff --git a/crates/horizon-world/src/level/ticks.rs b/crates/horizon-world/src/level/ticks.rs
index c8d715623..195078e31 100644
--- a/crates/horizon-world/src/level/ticks.rs
+++ b/crates/horizon-world/src/level/ticks.rs
@@ -29,6 +29,11 @@ pub struct Ticks {
     /// Moving-piston block entities in ticker order (render and collide
     /// moving blocks from these; see `piston_shape`).
     pub moving_pistons: Vec<(BlockPos, super::pistons::MovingPiston)>,
+    /// The pushes this tick's moving-piston block entities asked for: each
+    /// piston with the progress it is about to reach, in the order they ticked
+    /// (`PistonMovingBlockEntity.tick`'s `moveCollidedEntities` call). The
+    /// caller moves entities by these; `Ticks` has no entities of its own.
+    pub piston_pushes: Vec<(BlockPos, super::pistons::MovingPiston, f32)>,
     pub(crate) next_block_entity_id: u64,
     /// `ServerLevel.blockEvents`, run by `Behaviours::run_block_events`.
     pub block_events: Vec<super::pistons::BlockEventData>,
@@ -65,6 +70,7 @@ impl Ticks {
             comparator_outputs: Default::default(),
             torch_toggles: Vec::new(),
             moving_pistons: Vec::new(),
+            piston_pushes: Vec::new(),
             next_block_entity_id: 0,
             block_events: Vec::new(),
             handling_tick: false,
diff --git a/crates/horizon-world/src/lib.rs b/crates/horizon-world/src/lib.rs
index b6d05ecf6..6df870d42 100644
--- a/crates/horizon-world/src/lib.rs
+++ b/crates/horizon-world/src/lib.rs
@@ -94,6 +94,7 @@ pub mod nbt;
 pub mod object_open_map;
 pub mod object_open_set;
 pub mod piston_movement;
+pub mod piston_push;
 pub mod piston_shape;
 pub mod player_food;
 pub mod player_health;
diff --git a/crates/horizon-world/src/loot.rs b/crates/horizon-world/src/loot.rs
index 96ca5bdee..399c76f69 100644
--- a/crates/horizon-world/src/loot.rs
+++ b/crates/horizon-world/src/loot.rs
@@ -31,6 +31,9 @@ pub struct LootStack {
     pub exploration: Option<Box<ExplorationMap>>,
     /// Set by set_ominous_bottle_amplifier.
     pub ominous_amplifier: Option<i32>,
+    /// Added by set_stew_effect (the `suspicious_stew_effects` component):
+    /// (effect id, duration in ticks).
+    pub stew_effects: Vec<(String, i32)>,
 }
 /// `ExplorationMapFunction`'s settings.
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -74,6 +77,7 @@ impl LootStack {
             map: false,
             exploration: None,
             ominous_amplifier: None,
+            stew_effects: Vec::new(),
         }
     }
     pub fn is_empty(&self) -> bool {
@@ -150,6 +154,8 @@ pub struct LootEntity {
     pub captain: Option<bool>,
     /// A frog's variant id (`minecraft:warm`).
     pub frog_variant: Option<String>,
+    /// A chicken's variant id (`minecraft:warm`).
+    pub chicken_variant: Option<String>,
     /// A charged creeper (`Creeper.isPowered`).
     pub powered: bool,
     /// Worn and held items by `EquipmentSlot` name (mainhand, offhand,
@@ -678,6 +684,13 @@ impl LootData {
     }
 }
 
+/// `MobEffect.isInstantaneous`.
+fn is_instantaneous(effect: &str) -> bool {
+    matches!(
+        effect,
+        "minecraft:saturation" | "minecraft:instant_health" | "minecraft:instant_damage"
+    )
+}
 /// The level of one enchantment on a stack (its `enchantments` component).
 fn item_level(stack: &LootStack, enchantment: &str) -> i32 {
     stack
@@ -851,6 +864,9 @@ impl<R: RandomSource> Context<'_, R> {
                 "minecraft:frog/variant" => {
                     e.frog_variant.is_some() && want.as_str() == e.frog_variant.as_deref()
                 }
+                "minecraft:chicken/variant" => {
+                    e.chicken_variant.is_some() && want.as_str() == e.chicken_variant.as_deref()
+                }
                 _ => false,
             }),
             "minecraft:type_specific/sheep" => e
@@ -1134,7 +1150,14 @@ impl<R: RandomSource> Context<'_, R> {
                         .random
                         .next_int_bound(effects.len() as i32)
                         .unwrap_or(0) as usize;
-                    self.int(&effects[pick]["duration"]);
+                    let effect = effects[pick]["type"].as_str().unwrap_or("");
+                    let mut duration = self.int(&effects[pick]["duration"]);
+                    // Seconds, unless the effect is instantaneous.
+                    if !is_instantaneous(effect) {
+                        duration *= 20;
+                    }
+                    // SuspiciousStewEffects.withEffectAdded
+                    stack.stew_effects.push((effect.to_owned(), duration));
                 }
             }
             "minecraft:set_ominous_bottle_amplifier" => {
diff --git a/crates/horizon-world/src/piston_push.rs b/crates/horizon-world/src/piston_push.rs
new file mode 100644
index 000000000..5f64f22ba
--- /dev/null
+++ b/crates/horizon-world/src/piston_push.rs
@@ -0,0 +1,461 @@
+//! `PistonMovingBlockEntity.moveCollidedEntities`, `moveStuckEntities` and
+//! `fixEntityWithinPistonBase` over immutable geometry.
+//!
+//! Entity storage, the moving entities themselves and the blocks they collide
+//! with belong to the caller: these functions decide *how far* an entity is
+//! pushed, which is the part that must match vanilla to the bit. The movement
+//! they describe is an `Entity.move(MoverType.PISTON, …)`, so the caller still
+//! applies it through its own collision resolution and per-tick piston limit.
+use crate::{level::data::PushReaction, piston_shape::MovingPistonState};
+use horizon_core::{
+    geometry::{Aabb, Direction, Vec3},
+    position::BlockPos,
+};
+
+/// `PistonMovingBlockEntity.PUSH_OFFSET`.
+pub const PUSH_OFFSET: f64 = 0.01;
+
+/// `PistonMovingBlockEntity.getExtendedProgress`: where along its travel the
+/// moved block is, in blocks (negative before it starts, 0 when it arrives).
+pub fn extended_progress(piston: MovingPistonState, progress: f32) -> f32 {
+    if piston.extending {
+        progress - 1.0
+    } else {
+        1.0 - progress
+    }
+}
+
+/// `Direction.getAxisDirection().getStep()`.
+fn step_along(direction: Direction) -> i32 {
+    match direction {
+        Direction::East | Direction::Up | Direction::South => 1,
+        Direction::West | Direction::Down | Direction::North => -1,
+    }
+}
+
+/// `Direction.getStepX/Y/Z` as a vector.
+pub fn step_vector(direction: Direction) -> Vec3 {
+    let [x, y, z] = direction.normal();
+    Vec3::new(f64::from(x), f64::from(y), f64::from(z))
+}
+
+/// `PistonMath.getMovementArea`: the slab an entity's box must reach into to be
+/// run over by `amount` of further travel along `direction`.
+pub fn movement_area(aabb: Aabb, direction: Direction, amount: f64) -> Aabb {
+    let delta = amount * f64::from(step_along(direction));
+    let low = delta.min(0.0);
+    let high = delta.max(0.0);
+    let (min, max) = (aabb.min_position(), aabb.max_position());
+    match direction {
+        Direction::West => Aabb::new(
+            Vec3::new(min.x + low, min.y, min.z),
+            Vec3::new(min.x + high, max.y, max.z),
+        ),
+        Direction::East => Aabb::new(
+            Vec3::new(max.x + low, min.y, min.z),
+            Vec3::new(max.x + high, max.y, max.z),
+        ),
+        Direction::Down => Aabb::new(
+            Vec3::new(min.x, min.y + low, min.z),
+            Vec3::new(max.x, min.y + high, max.z),
+        ),
+        Direction::Up => Aabb::new(
+            Vec3::new(min.x, max.y + low, min.z),
+            Vec3::new(max.x, max.y + high, max.z),
+        ),
+        Direction::North => Aabb::new(
+            Vec3::new(min.x, min.y, min.z + low),
+            Vec3::new(max.x, max.y, min.z + high),
+        ),
+        Direction::South => Aabb::new(
+            Vec3::new(min.x, min.y, max.z + low),
+            Vec3::new(max.x, max.y, max.z + high),
+        ),
+    }
+}
+
+/// `PistonMovingBlockEntity.moveByPositionAndProgress`: a box moved to the
+/// block position and on to where the moved block currently is.
+pub fn move_by_position_and_progress(pos: BlockPos, aabb: Aabb, piston: MovingPistonState) -> Aabb {
+    let current = f64::from(extended_progress(piston, piston.progress));
+    let step = step_vector(piston.direction);
+    aabb.move_by(Vec3::new(
+        f64::from(pos.x) + current * step.x,
+        f64::from(pos.y) + current * step.y,
+        f64::from(pos.z) + current * step.z,
+    ))
+}
+
+/// `PistonMovingBlockEntity.getMovement`: how far `entity` stands inside the
+/// block it must be pushed out of, measured along `movement`'s axis.
+pub fn get_movement(block: Aabb, movement: Direction, entity: Aabb) -> f64 {
+    let (bmin, bmax) = (block.min_position(), block.max_position());
+    let (emin, emax) = (entity.min_position(), entity.max_position());
+    match movement {
+        Direction::East => bmax.x - emin.x,
+        Direction::West => emax.x - bmin.x,
+        Direction::Up => bmax.y - emin.y,
+        Direction::Down => emax.y - bmin.y,
+        Direction::South => bmax.z - emin.z,
+        Direction::North => emax.z - bmin.z,
+    }
+}
+
+/// `moveCollidedEntities`' inner loop: the furthest any of the moved block's
+/// boxes reaches into `entity`, capped at the progress delta, plus
+/// [`PUSH_OFFSET`]. `0.0` when the block does not touch the entity.
+pub fn collided_amount(
+    boxes: &[Aabb],
+    pos: BlockPos,
+    piston: MovingPistonState,
+    new_progress: f32,
+    movement: Direction,
+    entity: Aabb,
+) -> f64 {
+    let delta_progress = f64::from(new_progress - piston.progress);
+    let mut delta: f64 = 0.0;
+    for block in boxes {
+        let moving = movement_area(
+            move_by_position_and_progress(pos, *block, piston),
+            movement,
+            delta_progress,
+        );
+        if moving.intersects(entity) {
+            delta = delta.max(get_movement(moving, movement, entity));
+            if delta >= delta_progress {
+                break;
+            }
+        }
+    }
+    if delta <= 0.0 {
+        return 0.0;
+    }
+    delta.min(delta_progress) + PUSH_OFFSET
+}
+
+/// The box `level.getEntities` searches for a push: the moved block's own box
+/// widened by the slab it is about to sweep.
+pub fn movement_search_area(block_box: Aabb, movement: Direction, delta_progress: f64) -> Aabb {
+    movement_area(block_box, movement, delta_progress).union_bounds(block_box)
+}
+
+/// `moveStuckEntities`: the box of standing entities a moving honey block drags
+/// with it. `sticky_top` is the moved state's top collision height.
+pub fn sticky_area(pos: BlockPos, piston: MovingPistonState, sticky_top: f64) -> Aabb {
+    let area = Aabb::new(
+        Vec3::new(0.0, sticky_top, 0.0),
+        Vec3::new(1.0, 1.500_001_000_000_000_1, 1.0),
+    );
+    move_by_position_and_progress(pos, area, piston)
+}
+
+/// `PistonMovingBlockEntity.matchesStickyCritera`.
+pub fn matches_sticky_criteria(
+    area: Aabb,
+    reaction: PushReaction,
+    on_ground: bool,
+    supported_by_piston: bool,
+    entity_position: Vec3,
+) -> bool {
+    if reaction != PushReaction::PushPull || !on_ground {
+        return false;
+    }
+    if supported_by_piston {
+        return true;
+    }
+    let (min, max) = (area.min_position(), area.max_position());
+    entity_position.x >= min.x
+        && entity_position.x <= max.x
+        && entity_position.z >= min.z
+        && entity_position.z <= max.z
+}
+
+/// The level query intersects the sticky box before applying the predicate.
+pub fn sticky_entity_selected(
+    area: Aabb,
+    bounds: Aabb,
+    reaction: PushReaction,
+    on_ground: bool,
+    supported_by_piston: bool,
+    position: Vec3,
+) -> bool {
+    area.intersects(bounds)
+        && matches_sticky_criteria(area, reaction, on_ground, supported_by_piston, position)
+}
+
+/// `fixEntityWithinPistonBase`: a retracting source piston drags an entity that
+/// is still inside the piston's own block out along the opposite of `movement`.
+/// The returned distance is measured along that opposite direction.
+pub fn fix_within_piston_base(
+    pos: BlockPos,
+    entity: Aabb,
+    movement: Direction,
+    delta_progress: f64,
+) -> Option<f64> {
+    let block = Aabb::unit_cube(Vec3::from_block(pos));
+    if !entity.intersects(block) {
+        return None;
+    }
+    let opposite = movement.opposite();
+    let delta = get_movement(block, opposite, entity) + PUSH_OFFSET;
+    let intersected = entity.intersect(block);
+    let delta_intersected = get_movement(block, opposite, intersected) + PUSH_OFFSET;
+    // As deep inside as the block allows: it is stuck in the base itself, so it
+    // leaves along with the retraction.
+    if (delta - delta_intersected).abs() < PUSH_OFFSET {
+        Some(delta.min(delta_progress) + PUSH_OFFSET)
+    } else {
+        None
+    }
+}
+
+/// `PistonMovingBlockEntity.getCollisionRelatedBlockState` uses the moved state
+/// unless a source piston is retracting, where it shows a piston head instead.
+/// The state itself comes from [`PistonBlockBindings::collision_related_state`].
+///
+/// [`PistonBlockBindings::collision_related_state`]:
+///     crate::piston_shape::PistonBlockBindings::collision_related_state
+pub fn uses_moved_state(piston: MovingPistonState) -> bool {
+    piston.extending || !piston.source
+}
+
+/// `moveCollidedEntities`' slime bounce: a slime block sets the velocity along
+/// the movement axis to that direction's step, leaving the other axes.
+pub fn bounce_velocity(movement: Direction, velocity: Vec3) -> Vec3 {
+    let mut velocity = velocity;
+    match movement {
+        Direction::East => velocity.x = 1.0,
+        Direction::West => velocity.x = -1.0,
+        Direction::Up => velocity.y = 1.0,
+        Direction::Down => velocity.y = -1.0,
+        Direction::South => velocity.z = 1.0,
+        Direction::North => velocity.z = -1.0,
+    }
+    velocity
+}
+
+/// `Entity.getPistonPushReaction() == PushReaction.IGNORE_ENTITY`.
+///
+/// `Marker`, `Interaction`, `Display`, `AreaEffectCloud` and
+/// `OminousItemSpawner` return `IGNORE_ENTITY`, and an armor stand does when it
+/// is a marker. Horizon gives those kinds no pushed body, so a caller that has
+/// no box to push never reaches the maths above; this names the predicate for
+/// the kinds that do have one.
+pub fn ignores_push(marker: bool) -> bool {
+    marker
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn unit() -> Aabb {
+        Aabb::new(Vec3::new(0.0, 0.0, 0.0), Vec3::new(1.0, 1.0, 1.0))
+    }
+
+    fn moving(direction: Direction, extending: bool, progress: f32) -> MovingPistonState {
+        MovingPistonState {
+            moved_state: crate::registry::BlockStateId(0),
+            direction,
+            extending,
+            source: false,
+            progress,
+            previous_progress: progress,
+        }
+    }
+
+    /// `getMovementArea` puts the slab on the leading face and widens it by the
+    /// travel in that direction only.
+    #[test]
+    fn movement_area_sits_on_the_leading_face() {
+        let east = movement_area(unit(), Direction::East, 0.5);
+        assert_eq!(east.min_position(), Vec3::new(1.0, 0.0, 0.0));
+        assert_eq!(east.max_position(), Vec3::new(1.5, 1.0, 1.0));
+
+        let west = movement_area(unit(), Direction::West, 0.5);
+        assert_eq!(west.min_position(), Vec3::new(-0.5, 0.0, 0.0));
+        assert_eq!(west.max_position(), Vec3::new(0.0, 1.0, 1.0));
+
+        let up = movement_area(unit(), Direction::Up, 0.5);
+        assert_eq!(up.min_position(), Vec3::new(0.0, 1.0, 0.0));
+        assert_eq!(up.max_position(), Vec3::new(1.0, 1.5, 1.0));
+
+        let north = movement_area(unit(), Direction::North, 0.5);
+        assert_eq!(north.min_position(), Vec3::new(0.0, 0.0, -0.5));
+        assert_eq!(north.max_position(), Vec3::new(1.0, 1.0, 0.0));
+    }
+
+    /// A negative amount sweeps behind the leading face.
+    #[test]
+    fn movement_area_follows_a_negative_amount() {
+        let area = movement_area(unit(), Direction::East, -0.5);
+        assert_eq!(area.min_position(), Vec3::new(0.5, 0.0, 0.0));
+        assert_eq!(area.max_position(), Vec3::new(1.0, 1.0, 1.0));
+    }
+
+    /// The arm of a piston at the origin: the block entity sits in the block it
+    /// pushes into, and at progress 0 its shape is still a block back.
+    const ARM: BlockPos = BlockPos::new(1, 0, 0);
+
+    /// An entity in the way is pushed the progress delta, plus the push offset;
+    /// here it hangs 0.6 into the slab and the delta caps it at 0.5.
+    #[test]
+    fn a_collided_entity_moves_the_progress_delta() {
+        let piston = moving(Direction::East, true, 0.0);
+        let entity = Aabb::new(Vec3::new(0.9, 0.0, 0.2), Vec3::new(1.5, 1.8, 0.8));
+        let amount = collided_amount(&[unit()], ARM, piston, 0.5, Direction::East, entity);
+        assert!((amount - (0.5 + PUSH_OFFSET)).abs() < 1.0e-12, "{amount}");
+    }
+
+    /// The delta is not a floor: an entity barely nicking the slab moves by only
+    /// what it is owed, plus the offset.
+    #[test]
+    fn a_grazed_entity_moves_only_what_it_overlaps() {
+        let piston = moving(Direction::East, true, 0.0);
+        let entity = Aabb::new(Vec3::new(1.4, 0.0, 0.2), Vec3::new(2.0, 1.8, 0.8));
+        let amount = collided_amount(&[unit()], ARM, piston, 0.5, Direction::East, entity);
+        assert!((amount - (0.1 + PUSH_OFFSET)).abs() < 1.0e-12, "{amount}");
+    }
+
+    /// Clear of the block, nothing moves.
+    #[test]
+    fn an_entity_out_of_the_way_is_left_alone() {
+        let piston = moving(Direction::East, true, 0.0);
+        let entity = Aabb::new(Vec3::new(3.0, 0.0, 0.2), Vec3::new(3.6, 1.8, 0.8));
+        let amount = collided_amount(&[unit()], ARM, piston, 0.5, Direction::East, entity);
+        assert_eq!(amount, 0.0);
+    }
+
+    /// A retracting base drags an entity stuck inside its own block, limited by
+    /// the progress delta.
+    #[test]
+    fn a_retracting_base_drags_a_stuck_entity() {
+        let entity = Aabb::new(Vec3::new(0.75, 0.0, 0.2), Vec3::new(1.35, 1.8, 0.8));
+        let amount = fix_within_piston_base(BlockPos::new(0, 0, 0), entity, Direction::West, 0.5)
+            .expect("stuck in the base");
+        assert!(amount > 0.0 && amount <= 0.5 + PUSH_OFFSET, "{amount}");
+    }
+
+    /// An entity outside the base's block is not dragged by it.
+    #[test]
+    fn a_free_entity_is_not_dragged_by_the_base() {
+        let entity = Aabb::new(Vec3::new(2.0, 0.0, 0.2), Vec3::new(2.6, 1.8, 0.8));
+        assert_eq!(
+            fix_within_piston_base(BlockPos::new(0, 0, 0), entity, Direction::West, 0.5),
+            None
+        );
+    }
+
+    /// Honey drags only entities that stand on it and that blocks may push.
+    #[test]
+    fn honey_drags_standing_entities() {
+        let area = Aabb::new(Vec3::new(0.0, 0.0, 0.0), Vec3::new(1.0, 1.5, 1.0));
+        let on_top = Vec3::new(0.5, 0.0, 0.5);
+        assert!(matches_sticky_criteria(
+            area,
+            PushReaction::PushPull,
+            true,
+            false,
+            on_top
+        ));
+        assert!(!matches_sticky_criteria(
+            area,
+            PushReaction::PushPull,
+            false,
+            false,
+            on_top
+        ));
+        assert!(!matches_sticky_criteria(
+            area,
+            PushReaction::Immoveable,
+            true,
+            false,
+            on_top
+        ));
+        // Beside it: only standing on the piston's own block holds it.
+        let beside = Vec3::new(2.0, 0.0, 0.5);
+        assert!(!matches_sticky_criteria(
+            area,
+            PushReaction::PushPull,
+            true,
+            false,
+            beside
+        ));
+        assert!(matches_sticky_criteria(
+            area,
+            PushReaction::PushPull,
+            true,
+            true,
+            beside
+        ));
+    }
+
+    #[test]
+    fn honey_selection_uses_entity_position_and_intersection() {
+        let area = Aabb::new(Vec3::new(0.0, 1.0, 0.0), Vec3::new(1.0, 1.5, 1.0));
+        let position = Vec3::new(0.1, 1.0, 0.5);
+        let bounds = Aabb::new(Vec3::new(-0.2, 1.0, 0.2), Vec3::new(0.4, 2.8, 0.8));
+        assert!(sticky_entity_selected(
+            area,
+            bounds,
+            PushReaction::PushPull,
+            true,
+            false,
+            position
+        ));
+        let above = bounds.move_by(Vec3::new(0.0, 3.0, 0.0));
+        assert!(!sticky_entity_selected(
+            area,
+            above,
+            PushReaction::PushPull,
+            true,
+            true,
+            position
+        ));
+    }
+
+    /// The slime bounce rewrites only the movement axis.
+    #[test]
+    fn a_slime_block_bounces_along_its_axis() {
+        let v = Vec3::new(0.2, -0.5, 0.3);
+        assert_eq!(
+            bounce_velocity(Direction::East, v),
+            Vec3::new(1.0, -0.5, 0.3)
+        );
+        assert_eq!(bounce_velocity(Direction::Up, v), Vec3::new(0.2, 1.0, 0.3));
+        assert_eq!(
+            bounce_velocity(Direction::North, v),
+            Vec3::new(0.2, -0.5, -1.0)
+        );
+    }
+
+    /// The moved block sits along the piston's own direction, half a block short
+    /// at mid-travel and in place once landed.
+    #[test]
+    fn the_moved_block_sits_along_the_piston_direction() {
+        let half = moving(Direction::East, true, 0.5);
+        let moved = move_by_position_and_progress(BlockPos::new(2, 3, 4), unit(), half);
+        assert_eq!(moved.min_position(), Vec3::new(1.5, 3.0, 4.0));
+
+        let landed = moving(Direction::East, true, 1.0);
+        assert_eq!(
+            move_by_position_and_progress(BlockPos::new(2, 3, 4), unit(), landed).min_position(),
+            Vec3::new(2.0, 3.0, 4.0)
+        );
+
+        // Retracting runs the other way: two thirds out at progress 1/3.
+        let pulling = moving(Direction::East, false, 0.5);
+        assert_eq!(
+            move_by_position_and_progress(BlockPos::new(2, 3, 4), unit(), pulling).min_position(),
+            Vec3::new(2.5, 3.0, 4.0)
+        );
+    }
+
+    /// The search area covers the block and the slab in front of it.
+    #[test]
+    fn the_search_area_covers_block_and_sweep() {
+        let area = movement_search_area(unit(), Direction::East, 0.5);
+        assert_eq!(area.min_position(), Vec3::new(0.0, 0.0, 0.0));
+        assert_eq!(area.max_position(), Vec3::new(1.5, 1.0, 1.0));
+    }
+}
diff --git a/crates/horizon-world/src/worldgen/decoration_order.rs b/crates/horizon-world/src/worldgen/decoration_order.rs
index 6b0fb2252..0e53e7d09 100644
--- a/crates/horizon-world/src/worldgen/decoration_order.rs
+++ b/crates/horizon-world/src/worldgen/decoration_order.rs
@@ -29,7 +29,7 @@
 //! overlap), so a chunk may be decorated as soon as no lower-ranked chunk
 //! within two of it is still waiting: [`DecorationOrder::blocked`]. Chunks
 //! further apart still decorate in parallel.
-use std::collections::HashMap;
+use std::collections::{HashMap, VecDeque};
 
 #[derive(Default)]
 pub struct DecorationOrder {
@@ -121,7 +121,6 @@ fn ticket_hash(x: i32, z: i32) -> u64 {
 /// The chunks decorated around a player at `center`, in vanilla's order.
 pub fn vanilla_order(center: (i32, i32), radius: i32) -> Vec<(i32, i32)> {
     use std::cmp::Reverse;
-    use std::collections::{BinaryHeap, VecDeque};
     let mut tickets: Vec<(i32, i32)> = (-radius..=radius)
         .flat_map(|dx| (-radius..=radius).map(move |dz| (center.0 + dx, center.1 + dz)))
         .collect();
@@ -132,16 +131,31 @@ pub fn vanilla_order(center: (i32, i32), radius: i32) -> Vec<(i32, i32)> {
             Reverse(ticket_hash(x, z) & (TICKET_SET_CAPACITY - 1)),
         )
     });
-    let mut tickets: VecDeque<_> = tickets.into();
     // Every chunk this touches lies within `half` of the centre: tickets
     // reach `LIGHT_LEVEL - TICKET_LEVEL` further, and FULL tasks decorate
-    // one more ring. Dense grids over that square replace hash maps.
+    // one more ring.
+    let half = radius.max(0) + LIGHT_LEVEL - TICKET_LEVEL + 1;
+    ticket_order(
+        tickets.into(),
+        TICKETS_IN_FLIGHT,
+        (center.0 - half, center.1 - half),
+        (2 * half + 1) as usize,
+    )
+}
+
+/// The decoration order of `tickets` (level 31) added in turn, at most
+/// `in_flight` at a time. Dense grids of `side` chunks from `origin` hold
+/// every chunk this touches, in place of hash maps.
+fn ticket_order(
+    mut tickets: VecDeque<(i32, i32)>,
+    in_flight: usize,
+    origin: (i32, i32),
+    side: usize,
+) -> Vec<(i32, i32)> {
+    use std::cmp::Reverse;
+    use std::collections::BinaryHeap;
     let reach = LIGHT_LEVEL - TICKET_LEVEL;
-    let half = radius.max(0) + reach + 1;
-    let side = (2 * half + 1) as usize;
-    let cell = |(x, z): (i32, i32)| {
-        ((x - center.0 + half) as usize) * side + (z - center.1 + half) as usize
-    };
+    let cell = |(x, z): (i32, i32)| ((x - origin.0) as usize) * side + (z - origin.1) as usize;
     let mut active: Vec<(i32, i32)> = Vec::new();
     // Queued task per chunk (level, sequence), `NONE` when there is none;
     // stale heap entries are skipped.
@@ -177,10 +191,9 @@ pub fn vanilla_order(center: (i32, i32), radius: i32) -> Vec<(i32, i32)> {
             }
         }
     };
-    for _ in 0..TICKETS_IN_FLIGHT {
-        if let Some(t) = tickets.pop_front() {
-            add(t, &mut active, &mut queued, &mut heap, &full);
-        }
+    while active.len() < in_flight {
+        let Some(t) = tickets.pop_front() else { break };
+        add(t, &mut active, &mut queued, &mut heap, &full);
     }
     while let Some(Reverse((l, s, chunk))) = heap.pop() {
         let i = cell(chunk);
@@ -202,7 +215,7 @@ pub fn vanilla_order(center: (i32, i32), radius: i32) -> Vec<(i32, i32)> {
             full[i] = true;
         }
         active.retain(|t| !(-2..=2).all(|dx| (-2..=2).all(|dz| full[cell((t.0 + dx, t.1 + dz))])));
-        while active.len() < TICKETS_IN_FLIGHT {
+        while active.len() < in_flight {
             let Some(t) = tickets.pop_front() else { break };
             add(t, &mut active, &mut queued, &mut heap, &full);
         }
@@ -210,10 +223,36 @@ pub fn vanilla_order(center: (i32, i32), radius: i32) -> Vec<(i32, i32)> {
     order
 }
 
+/// The chunks `/forceload add` over chunks `(x0, z0)..=(x1, z1)` decorates,
+/// in vanilla's order: ForceLoadCommand adds a FORCED ticket (level 31) per
+/// chunk, x-outer, z-inner, all at once.
+pub fn forced_order(x0: i32, z0: i32, x1: i32, z1: i32) -> Vec<(i32, i32)> {
+    let tickets = (x0..=x1)
+        .flat_map(|x| (z0..=z1).map(move |z| (x, z)))
+        .collect();
+    let pad = LIGHT_LEVEL - TICKET_LEVEL + 1;
+    let side = ((x1 - x0).max(z1 - z0) + 2 * pad + 1) as usize;
+    ticket_order(tickets, usize::MAX, (x0 - pad, z0 - pad), side)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    /// Seed 8675309's geodes in chunks (-26, -1) and (14, -20) run into the
+    /// trial chambers of (-26, 0) and (14, -19); vanilla decorates the lower
+    /// z first, wherever the batch lies, so the chambers are drawn over them.
+    #[test]
+    fn forced_chunks_decorate_x_outer_z_inner() {
+        let rank = |order: &[(i32, i32)], c| order.iter().position(|&o| o == c).unwrap();
+        let west = forced_order(-32, -16, -17, -1);
+        assert!(rank(&west, (-26, -1)) < rank(&west, (-26, 0)));
+        let east = forced_order(0, -32, 15, -17);
+        assert!(rank(&east, (14, -20)) < rank(&east, (14, -19)));
+        assert_eq!(west[0], (-33, -17));
+        assert_eq!(west.len(), 22 * 22);
+    }
+
     /// The hash map version this module had before its dense grids.
     fn hashed_order(center: (i32, i32), radius: i32) -> Vec<(i32, i32)> {
         use std::cmp::Reverse;
diff --git a/crates/horizon-world/src/worldgen/generator.rs b/crates/horizon-world/src/worldgen/generator.rs
index 7a38608be..f3bf7cab7 100644
--- a/crates/horizon-world/src/worldgen/generator.rs
+++ b/crates/horizon-world/src/worldgen/generator.rs
@@ -23,6 +23,7 @@ use super::{
     climate::{ClimateSampler, decode_parameter, quantize},
     decode_noise,
     density::DensityRegistry,
+    generator_structures::Starts,
     material_condition::{
         MaterialConditionRegistry, MaterialConditions, MaterialDensitySources, MaterialRule,
         MaterialRuleError, MaterialRuleLibrary, MaterialSurfaceQueries,
@@ -567,6 +568,9 @@ pub struct ProtoChunk {
     pub block_entities: Vec<([i32; 3], crate::nbt::Compound)>,
     /// Structure starts referencing this chunk (STRUCTURE_REFERENCES).
     pub(super) structure_starts: Vec<Arc<super::structure::start::StructureStart>>,
+    /// The starts made in this chunk (STRUCTURE_STARTS), also those none of
+    /// whose pieces reach it (a giant ruined portal next door).
+    own_starts: Starts,
     /// Entities placed by structures (`ProtoChunk.addEntity`), as NBT with
     /// absolute `Pos`.
     pub entities: Vec<crate::nbt::Compound>,
@@ -620,12 +624,7 @@ impl ProtoChunk {
     }
     /// The structure starts this chunk holds itself (`structures.starts`).
     pub fn own_starts(&self) -> Vec<Arc<super::structure::start::StructureStart>> {
-        let pos = self.position();
-        self.structure_starts
-            .iter()
-            .filter(|s| s.chunk == pos)
-            .cloned()
-            .collect()
+        self.own_starts.to_vec()
     }
     /// Also restores a saved proto chunk that was decorated before it was saved.
     pub fn set_decorated(&mut self) {
@@ -1114,16 +1113,19 @@ where
         )
         .map_err(stage("noise"))?;
         chunk.set_generation_stage(PreLightChunkStage::Biomes);
-        let references = match &self.structures {
-            Some(structures) => structures.references(
-                &mut StructureQueries {
+        let (references, own_starts) = match &self.structures {
+            Some(structures) => {
+                let mut queries = StructureQueries {
                     pipeline: self,
                     worker,
                     valid: BTreeSet::new(),
-                },
-                pos,
-            ),
-            None => Vec::new(),
+                };
+                (
+                    structures.references(&mut queries, pos),
+                    structures.starts_at(&mut queries, pos),
+                )
+            }
+            None => (Vec::new(), Starts::default()),
         };
         if let Some(beard) = self
             .structures
@@ -1259,6 +1261,7 @@ where
             decorated: false,
             block_entities: Vec::new(),
             structure_starts: references,
+            own_starts,
             entities: Vec::new(),
         })
     }
@@ -1648,6 +1651,22 @@ pub(super) struct WorkerState {
     heights: HashMap<(i32, i32, u8), i32>,
     /// Decorate with structure pieces only (for structure parity checks).
     pub(super) structures_only: bool,
+    pub(super) structure_mobs: Option<Arc<dyn StructureMobs>>,
+}
+/// `Mob.finalizeSpawn(level, difficulty, STRUCTURE, null)` of the entities a
+/// structure places with finalizeEntities, run by the game, which owns mobs.
+pub trait StructureMobs: Send + Sync {
+    /// Finalizes the entity in `nbt` if it is a mob, drawing from the
+    /// region's random. `biome` is the biome at its block, `structures` the
+    /// structures with a piece there. False when it could not: the entity
+    /// keeps its `horizon:finalize` for the game to finish on load.
+    fn finalize(
+        &self,
+        nbt: &mut crate::nbt::Compound,
+        biome: &str,
+        structures: &[String],
+        random: &mut dyn super::structure::legacy::PieceRandom,
+    ) -> bool;
 }
 
 trait SeededPipeline: Send + Sync {
@@ -2464,6 +2483,7 @@ impl OverworldGenerator {
                 carver_biomes: HashMap::new(),
                 timings: StageTimings::default(),
                 structures_only: false,
+                structure_mobs: None,
                 heights: HashMap::new(),
             },
         }
@@ -2590,6 +2610,9 @@ impl GeneratorWorker {
     pub fn set_structures_only(&mut self, only: bool) {
         self.state.structures_only = only;
     }
+    pub fn set_structure_mobs(&mut self, mobs: Arc<dyn StructureMobs>) {
+        self.state.structure_mobs = Some(mobs);
+    }
 }
 
 #[cfg(test)]
@@ -2975,6 +2998,26 @@ mod tests {
         }
     }
 
+    /// Seed 8675309's giant ruined portal starts in chunk (-26, 23) and lies
+    /// wholly in (-26, 24): its own chunk still holds the start, as vanilla's
+    /// getAllStarts does, though no piece reaches it.
+    #[test]
+    fn a_chunk_holds_its_starts_whose_pieces_lie_elsewhere() {
+        let Some(data) = prepared_data() else {
+            return;
+        };
+        let generator = OverworldGenerator::new(data, 8675309).expect("generator");
+        let mut worker = generator.worker();
+        let proto = worker
+            .generate_proto(ChunkPos::new(-26, 23))
+            .expect("proto");
+        let own: Vec<_> = proto.own_starts().iter().map(|s| s.name.clone()).collect();
+        assert!(
+            own.iter().any(|n| n == "minecraft:ruined_portal_mountain"),
+            "{own:?}"
+        );
+    }
+
     /// Chunks no ring search can end near are decided without the rings,
     /// which stay unsearched, and get the starts they get with them.
     #[test]
diff --git a/crates/horizon-world/src/worldgen/generator_decoration.rs b/crates/horizon-world/src/worldgen/generator_decoration.rs
index fc1cd8bcf..0f3ea6810 100644
--- a/crates/horizon-world/src/worldgen/generator_decoration.rs
+++ b/crates/horizon-world/src/worldgen/generator_decoration.rs
@@ -310,6 +310,7 @@ impl Decoration {
             Err(e) => return Err(resource(e.to_string())),
         };
         let structures_only = worker.structures_only;
+        let references = region[4].structure_starts.clone();
         let mut block_entities = Vec::new();
         for chunk in region.iter_mut() {
             block_entities.append(&mut chunk.block_entities);
@@ -318,6 +319,9 @@ impl Decoration {
             block_entities,
             entities: Vec::new(),
             level_random,
+            structure_mobs: worker.structure_mobs.clone(),
+            starts: references.clone(),
+            biome_names: data.biome_names(),
             blocks: data
                 .feature_resources
                 .as_ref()
@@ -334,7 +338,6 @@ impl Decoration {
         };
         let mut stats = DecorateStats::default();
         let blocks = self.blocks;
-        let references = region[4].structure_starts.clone();
         // ChunkGenerator.getWritableArea: the chunk's minimum Y + 1 to its maximum Y.
         let chunk_box = BoundingBox::new(
             [center.x * 16, min_y + 1, center.z * 16],
@@ -419,15 +422,11 @@ impl Decoration {
         }
         // WorldGenRegion.addFreshEntity: into the chunk holding the position.
         for nbt in std::mem::take(&mut world.entities) {
-            let Some(crate::nbt::Tag::List(p)) = nbt.get(&"Pos".into()) else {
+            let Some(at) = block_of(&nbt) else {
                 continue;
             };
-            let coord = |i: usize| match p.get(i) {
-                Some(crate::nbt::Tag::Double(b)) => f64::from_bits(*b).floor() as i32,
-                _ => 0,
-            };
-            let index = ((coord(2) >> 4).wrapping_sub(center.z) + 1) * 3
-                + (coord(0) >> 4).wrapping_sub(center.x)
+            let index = ((at[2] >> 4).wrapping_sub(center.z) + 1) * 3
+                + (at[0] >> 4).wrapping_sub(center.x)
                 + 1;
             if let Some(chunk) = usize::try_from(index).ok().and_then(|i| region.get_mut(i)) {
                 chunk.entities.push(nbt);
@@ -454,6 +453,9 @@ struct World<'a> {
     block_entities: Vec<([i32; 3], crate::nbt::Compound)>,
     entities: Vec<crate::nbt::Compound>,
     level_random: &'a mut dyn super::structure::legacy::PieceRandom,
+    structure_mobs: Option<Arc<dyn super::generator::StructureMobs>>,
+    starts: Vec<Arc<super::structure::start::StructureStart>>,
+    biome_names: &'a [Arc<str>],
     blocks: Option<&'a BlockBehavior>,
     region: TerrainRegion<'static, GenBlockStates>,
     biomes: BiomeRegion<BiomeId>,
@@ -847,10 +849,57 @@ impl PlacementContext for World<'_> {
                 (0..ny).all(|y| (0..nz).all(|z| shape.is_full(x as i32, y as i32, z as i32)))
             }))
     }
-    fn add_entity(&mut self, nbt: crate::nbt::Compound) -> Result<(), PlacementQueryError> {
+    fn add_entity(&mut self, mut nbt: crate::nbt::Compound) -> Result<(), PlacementQueryError> {
+        if let Some(mobs) = self.structure_mobs.clone()
+            && nbt.contains_key(&"horizon:finalize".into())
+        {
+            let at = block_of(&nbt).unwrap_or([0; 3]);
+            let biome = self
+                .biome_identity(at)
+                .ok()
+                .and_then(|b| self.biome_names.get(b.0 as usize))
+                .map_or("", |n| &**n)
+                .to_owned();
+            let structures: Vec<String> = self
+                .starts
+                .iter()
+                .filter(|s| s.pieces.iter().any(|p| p.bounding_box().is_inside(at)))
+                .map(|s| s.name.clone())
+                .collect();
+            if mobs.finalize(&mut nbt, &biome, &structures, self.level_random) {
+                nbt.remove(&"horizon:finalize".into());
+            }
+        }
         self.entities.push(nbt);
         Ok(())
     }
+    /// SpikeFeature.placeSpike: the crystal is a fresh entity of the region,
+    /// saved with the chunk.
+    fn spawn_end_crystal(
+        &mut self,
+        position: [f64; 3],
+        yaw: f32,
+        beam_target: Option<[i32; 3]>,
+        invulnerable: bool,
+    ) -> Result<(), PlacementQueryError> {
+        use crate::nbt::Tag;
+        let mut nbt = crate::nbt::Compound::new();
+        nbt.insert("id".into(), Tag::String("minecraft:end_crystal".into()));
+        nbt.insert(
+            "Pos".into(),
+            Tag::List(position.iter().map(|v| Tag::Double(v.to_bits())).collect()),
+        );
+        nbt.insert(
+            "Rotation".into(),
+            Tag::List(vec![Tag::Float(yaw.to_bits()), Tag::Float(0)]),
+        );
+        nbt.insert("Invulnerable".into(), Tag::Byte(i8::from(invulnerable)));
+        nbt.insert("ShowBottom".into(), Tag::Byte(1));
+        if let Some(b) = beam_target {
+            nbt.insert("beam_target".into(), Tag::IntArray(b.to_vec()));
+        }
+        self.add_entity(nbt)
+    }
     fn set_block_entity(
         &mut self,
         position: [i32; 3],
@@ -1167,3 +1216,14 @@ impl PlacementContext for World<'_> {
         Ok(Some(false))
     }
 }
+
+/// The block an entity's `Pos` is in.
+fn block_of(nbt: &crate::nbt::Compound) -> Option<[i32; 3]> {
+    let Some(crate::nbt::Tag::List(p)) = nbt.get(&"Pos".into()) else {
+        return None;
+    };
+    Some(std::array::from_fn(|i| match p.get(i) {
+        Some(crate::nbt::Tag::Double(b)) => f64::from_bits(*b).floor() as i32,
+        _ => 0,
+    }))
+}
diff --git a/crates/horizon-world/src/worldgen/structure/legacy.rs b/crates/horizon-world/src/worldgen/structure/legacy.rs
index 785b5fb2e..19d121718 100644
--- a/crates/horizon-world/src/worldgen/structure/legacy.rs
+++ b/crates/horizon-world/src/worldgen/structure/legacy.rs
@@ -31,14 +31,19 @@ pub type Markers = Vec<(String, [i32; 3])>;
 pub trait PieceRandom: ProcessorRandom {
     fn boolean(&mut self) -> bool;
     fn double(&mut self) -> f64;
+    /// The concrete random, for callers that need all of `RandomSource`.
+    fn as_any(&mut self) -> &mut dyn std::any::Any;
 }
-impl<R: RandomSource> PieceRandom for R {
+impl<R: RandomSource + 'static> PieceRandom for R {
     fn boolean(&mut self) -> bool {
         self.next_boolean()
     }
     fn double(&mut self) -> f64 {
         self.next_double()
     }
+    fn as_any(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
 }
 
 /// Object-safe world access for piece post-processing.
diff --git a/crates/horizon-world/src/worldgen/structure/mineshaft.rs b/crates/horizon-world/src/worldgen/structure/mineshaft.rs
index 0c2d32c08..082afd0cd 100644
--- a/crates/horizon-world/src/worldgen/structure/mineshaft.rs
+++ b/crates/horizon-world/src/worldgen/structure/mineshaft.rs
@@ -616,6 +616,9 @@ impl MineshaftPiece {
             // A chest minecart with the mineshaft loot table.
             let seed = c.random.long();
             let mut nbt = super::legacy::spawn_nbt("minecraft:chest_minecart", pos, false, false);
+            // As the proto chunk saves the new cart: not ticked, not burning.
+            nbt.insert("HasTicked".into(), Tag::Byte(1));
+            nbt.insert("Fire".into(), Tag::Short(0));
             let p = [
                 f64::from(pos[0]) + 0.5,
                 f64::from(pos[1]) + 0.5,
diff --git a/crates/horizon-world/src/worldgen/structure/start.rs b/crates/horizon-world/src/worldgen/structure/start.rs
index 810332c61..f84a953a1 100644
--- a/crates/horizon-world/src/worldgen/structure/start.rs
+++ b/crates/horizon-world/src/worldgen/structure/start.rs
@@ -275,16 +275,15 @@ fn terrain(name: Option<&str>) -> TerrainAdjustment {
         _ => TerrainAdjustment::None,
     }
 }
-fn pair(value: Option<&Value>, a: &str, b: &str, default: i32) -> [i32; 2] {
+/// A jigsaw field given as one number or as an object of two. In the object a
+/// missing `a` is 0 and a missing `b` is `missing_b` (`JigsawStructure.MaxDistance`
+/// and `DimensionPadding` default their second value, not copy the first).
+fn pair(value: Option<&Value>, a: &str, b: &str, default: i32, missing_b: i32) -> [i32; 2] {
     match value {
         Some(Value::Number(n)) => [n.as_i64().unwrap_or(0) as i32; 2],
         Some(Value::Object(o)) => {
-            let get = |k: &str| o.get(k).and_then(Value::as_i64).unwrap_or(0) as i32;
-            let first = get(a);
-            [
-                first,
-                o.get(b).and_then(Value::as_i64).map_or(first, |v| v as i32),
-            ]
+            let get = |k: &str| o.get(k).and_then(Value::as_i64).map(|v| v as i32);
+            [get(a).unwrap_or(0), get(b).unwrap_or(missing_b)]
         }
         _ => [default; 2],
     }
@@ -326,9 +325,11 @@ impl StructureRegistry {
                         "horizontal",
                         "vertical",
                         80,
+                        // DimensionType.Y_SIZE.
+                        4064,
                     ),
                     aliases: v["pool_aliases"].as_array().cloned().unwrap_or_default(),
-                    padding: pair(v.get("dimension_padding"), "bottom", "top", 0),
+                    padding: pair(v.get("dimension_padding"), "bottom", "top", 0, 0),
                     waterlogging: v["liquid_settings"].as_str() != Some("ignore_waterlogging"),
                     checks: super::start_checks::StartChecks::decode(v.get("horizon:start_checks")),
                     piece_limited: v
diff --git a/docs/api/mods-reference.md b/docs/api/mods-reference.md
index c44f27576..b25ef5b9e 100644
--- a/docs/api/mods-reference.md
+++ b/docs/api/mods-reference.md
@@ -17,6 +17,8 @@ The contract between Horizon and its mods: the WIT package `horizon:mods@0.1.0`,
 | `render` | [`render`](#render) | draw on your screen, shake and zoom the camera |
 | `input` | [`input`](#input) | see the keys you hold and your clicks, take over the use button on its own items and the mouse wheel, and add keys |
 | `players` | [`players`](#players) | see who is on the server and message them |
+| `world` | [`world`](#world) | read and change the world's blocks |
+| `recipes` | [`recipes`](#recipes) | read the game's recipes and items and which recipes you know, place recipes in your crafting grid and, in creative mode, give you items |
 
 ## World `horizon-mod`
 
@@ -29,14 +31,14 @@ A client mod: runs in the player's game.
 
 A server mod (manifest `side = "server"`, `api = "0.3"`, experimental): runs where the world is simulated, on the dedicated server, a LAN host and single player's own server.
 
-- Imports (what the game offers): `log`, `storage`, `players`
+- Imports (what the game offers): `log`, `storage`, `players`, `world`
 - Exports (what the mod provides): `server-events`
 
 ## World `horizon-ui-mod`
 
 A mod with widgets (capability `ui`): the SDK builds every mod against this world. Mods built for `horizon-mod` alone (no `ui-events` export) still load and simply hear nothing of their widgets.
 
-- Imports (what the game offers): `ui`, `render`, `input`, `log`, `game`, `chat`, `hud`, `storage`, `command`
+- Imports (what the game offers): `ui`, `render`, `input`, `recipes`, `browser`, `log`, `game`, `chat`, `hud`, `storage`, `command`
 - Exports (what the mod provides): `ui-events`, `events`
 
 ## World `ui-host`
@@ -53,6 +55,13 @@ The game's side of capability `render` (imports only).
 - Imports (what the game offers): `render`, `input`
 - Exports (what the mod provides): 
 
+## World `recipes-host`
+
+The game's side of capability `recipes` (imports only).
+
+- Imports (what the game offers): `recipes`, `browser`
+- Exports (what the mod provides): 
+
 ## `log`
 
 Access: always granted.
@@ -426,6 +435,13 @@ Any four-cornered shape (a wheel's segment, an arrow): the corners in order roun
 | `rotate` | `bool` | The map turns with the player, who faces up, and an N on its rim marks north. Otherwise north is up and the player's arrow turns. |
 | `round` | `bool` | Round, the corners left clear; otherwise square. |
 
+### record `far-terrain`
+
+| Field | Type | |
+| --- | --- | --- |
+| `distance` | `u32` | How far the distant terrain reaches, in chunks: 64 to 1024. On integrated graphics other than Apple's the game caps it lower. |
+| `reduced` | `bool` | Coarser far tiles, as the Far Detail setting's Reduced: 2 to 4 ms less GPU time per frame on integrated graphics. |
+
 | Function | Signature | What it does |
 | --- | --- | --- |
 | `set-hud` | `func(shapes: list<shape>)` | Replaces the mod's HUD shapes: up to 1024, drawn every frame in order over the HUD (after the hotbar, under chat and screens), hidden with the HUD (F1). An empty list removes them. |
@@ -437,6 +453,7 @@ Any four-cornered shape (a wheel's segment, an arrow): the corners in order roun
 | `frame-stats` | `func() -> frame-rate` | The game's frame counter, recomputed twice a second. |
 | `set-zoom` | `func(zoom: zoom)` | Zooms the camera until the next call (`factor` 1 ends it), only while playing: a screen opening or the spyglass's own view (which wins) leave the camera vanilla's. With several mods, the strongest zoom counts. |
 | `set-minimap` | `func(minimap: option<minimap>)` | Shows a map of the world around the player in `corner`, stacked with the game's overlays and the mods' panels, until the next call (none hides it). It looks like a map item: vanilla's map colours with their height shading and water depth, and the player's arrow. Underground, under a roof and in the Nether it maps the floor around the player's height. The game keeps the map's tiles and refreshes them within its own frame budget; hidden, they are dropped. One map shows at a time: the first loaded mod's. |
+| `set-far-terrain` | `func(far-terrain: option<far-terrain>)` | Draws the world beyond the render distance as distant terrain, out to `distance` chunks, until the next call (none ends it). The game builds it on its own workers, from the chunks already loaded or saved and, where nobody has been, from the world's generator; the simulation distance doesn't change. Only worlds whose generator the game has (single player and a LAN world you host) show it. The player's own LOD Distance setting, when on, wins. One far terrain shows at a time: the first loaded mod's. |
 
 ## `events`
 
@@ -461,6 +478,160 @@ What the game calls. Only the hooks `init` asks for are ever called.
 | `command` | `func(name: string, args: string) -> result<option<string>, string>` | `/name args`: ok(some(text)) is shown as feedback, err(text) in red. |
 | `chat` | `func(text: string)` | Each chat line the player receives, as plain text. |
 
+## `recipes`
+
+Access: capability `recipes`.
+
+Capability `recipes` (experimental): the recipes and items the game knows, for recipe viewers. In single player and on Horizon's servers they are the world's; on any other server they are vanilla 26.3's (a client is sent no others), while `known` follows that server's book.
+
+### record `stack`
+
+An item of `items`, by its index there, with a count and the components it has beyond the item's own, in vanilla's item syntax (`[potion_contents={potion:"minecraft:swiftness"}]`), or "".
+
+| Field | Type | |
+| --- | --- | --- |
+| `item` | `u32` |  |
+| `count` | `u32` |  |
+| `components` | `string` |  |
+
+### enum `kind`
+
+The station a recipe is made at.
+
+| Case | |
+| --- | --- |
+| `crafting-shaped` |  |
+| `crafting-shapeless` |  |
+| `smelting` |  |
+| `blasting` |  |
+| `smoking` |  |
+| `campfire` |  |
+| `stonecutting` |  |
+| `smithing` |  |
+| `brewing` |  |
+
+### record `recipe`
+
+| Field | Type | |
+| --- | --- | --- |
+| `id` | `string` | `minecraft:oak_planks`. |
+| `kind` | `kind` |  |
+| `category` | `string` | The recipe book's tab (`crafting_building_blocks`, `furnace_food`), or "". |
+| `group` | `string` | Recipes the book shows on one button share a group, or "". |
+| `width` | `u32` | A shaped recipe's grid: `slots` holds its cells row by row. 0 for the other kinds. |
+| `height` | `u32` |  |
+| `slots` | `list<list<stack>>` | Each slot's stacks, any one of which fits; an empty list is an empty cell. Cooking and stonecutting: the input. Smithing: the template, the base, the addition. Brewing: the bottle, the reagent. |
+| `results` | `list<stack>` | What it makes; several when that varies (a trim on any armour). |
+| `cooking-time` | `u32` | Cooking: game ticks and experience; 0 for the other kinds. |
+| `experience` | `f32` |  |
+| `book-id` | `s32` | The recipe book's id for it (one per way the book shows it), as `known` lists them; -1 for the kinds the book doesn't show (campfire, stonecutting, smithing, brewing). |
+
+### record `item`
+
+| Field | Type | |
+| --- | --- | --- |
+| `id` | `string` | `minecraft:diamond`, `<mod>:<path>`. |
+| `name` | `string` | In the player's language. |
+| `tags` | `list<string>` | Its item tags, without the `#`. |
+
+| Function | Signature | What it does |
+| --- | --- | --- |
+| `items` | `func() -> list<item>` | Every item, in the registry's order: `stack.item` indexes this list. |
+| `all` | `func() -> list<recipe>` | Every recipe: the book's in its order, then campfire, stonecutting, smithing and brewing. They don't change while a world is open. |
+| `known` | `func() -> list<s32>` | The `book-id`s of the recipes the player's recipe book holds now. |
+| `place` | `func(book-id: s32, all: bool) -> result<_, string>` | Places a recipe in the open screen's grid as a click in the recipe book does (`ServerboundPlaceRecipePacket`): the inventory's grid or a crafting table. `all` places as many as the items allow, as with Shift. Refused while no such screen is open, for a recipe the player's book doesn't hold and for one that can't be placed; one missing items shows as a ghost in the grid, as in the book. |
+| `give` | `func(stack: stack) -> result<_, string>` | Creative mode only: gives the player the stack, as taking it from the creative inventory does (`ServerboundSetCreativeModeSlot`): the selected slot first, then the hotbar, then the inventory. The count is cut to one stack of the item (64, 16 or 1). |
+
+## `browser`
+
+Access: not granted by any capability.
+
+Capability `ui` (experimental): a recipe viewer's panel beside the game's inventory and container screens (not the creative inventory), on the right of the screen. The game draws it with its own widgets and slots, pages it and keeps its search box; the mod says what it holds. The first loaded mod with a panel shows.
+
+### record `stack`
+
+An item to show: its id, a count (1 draws none) and its components beyond the item's own, in vanilla's item syntax, or "".
+
+| Field | Type | |
+| --- | --- | --- |
+| `item` | `string` |  |
+| `count` | `u32` |  |
+| `components` | `string` |  |
+
+### record `click`
+
+A click on an item of the panel, by its index in `set-items`'s list.
+
+| Field | Type | |
+| --- | --- | --- |
+| `index` | `u32` |  |
+| `right` | `bool` |  |
+
+### record `item-key`
+
+A key the mod registered (`input.register-key`) went down while the pointer was on an item: a slot of the screen's, or the panel's.
+
+| Field | Type | |
+| --- | --- | --- |
+| `key` | `string` |  |
+| `stack` | `stack` |  |
+
+### record `slot-click`
+
+A click on a slot of a recipe the panel shows (`set-recipes`).
+
+| Field | Type | |
+| --- | --- | --- |
+| `recipe` | `u32` | The recipe's index in `set-recipes`'s list and the slot's in it; the results come after the slots. |
+| `slot` | `u32` |  |
+| `stack` | `stack` | The stack the slot showed at that moment. |
+| `right` | `bool` |  |
+
+### variant `event`
+
+| Case | Payload | |
+| --- | --- | --- |
+| `clicked` | `click` |  |
+| `search` | `string` | The search box's text, each time the player changes it. |
+| `key` | `item-key` |  |
+| `slot-clicked` | `slot-click` |  |
+| `action` | `u32` | The action button of the recipe at this index in `set-recipes`'s list. |
+| `page` | `u32` | The player turned the recipes' page (`set-recipes`): the index of the first recipe now shown. |
+| `back` |  | The back button of `set-recipes`. |
+| `tab` | `u32` | The player picked the tab at this index of `set-recipes`' tabs. |
+
+### enum `layout`
+
+How the game lays out a recipe of `set-recipes`.
+
+| Case | |
+| --- | --- |
+| `grid` | A crafting grid of `width` x `height` slots, an arrow and the result. |
+| `cooking` | One input over a flame, an arrow and the result (furnaces, smokers, campfires). |
+| `single` | One input, an arrow and the result (the stonecutter). |
+| `smithing` | Template, base and addition, an arrow and the result. |
+| `brewing` | A potion and an ingredient, an arrow and the result. |
+
+### record `recipe-view`
+
+A recipe to show. Each slot, and the result, cycles through its stacks, one a second; an empty slot shows nothing.
+
+| Field | Type | |
+| --- | --- | --- |
+| `layout` | `layout` |  |
+| `width` | `u32` | The grid's size (`grid` only), at most 3 x 3. |
+| `height` | `u32` |  |
+| `slots` | `list<list<stack>>` |  |
+| `results` | `list<stack>` |  |
+| `note` | `string` | A short line under the recipe (a cooking time), or "". |
+| `action` | `option<bool>` | The action button beside it: none, enabled, or shown greyed. |
+
+| Function | Signature | What it does |
+| --- | --- | --- |
+| `set-items` | `func(items: list<stack>)` | The panel's items, at most 8192 (an empty list hides the panel). |
+| `set-recipes` | `func(title: string, tabs: list<stack>, tab: u32, recipes: list<recipe-view>)` | Shows these recipes in the panel instead of its items, as many as fit a page, under `title` and a back button, with a row of `tabs` (each an icon; `tab` is the selected one) between them; an empty list of recipes shows the items again. At most 256 recipes and 16 tabs. |
+| `poll` | `func() -> list<event>` | What the player did on the panel since the last poll, at most 256 kept. |
+
 ## `players`
 
 Access: capability `players`.
@@ -495,6 +666,27 @@ Capability `players`, server mods only (manifest `api = "0.3"`, experimental): t
 | `tell` | `func(player: string, text: string) -> bool` | A system message to one player, after the mod's name; false when no player with that id is online. Up to 8 messages per call. |
 | `broadcast` | `func(text: string)` | A system message to every player and the server's log, after the mod's name. Counts toward the same 8 per call. |
 
+## `world`
+
+Access: capability `world`.
+
+Capability `world`, server mods only (manifest `api = "0.3"`, experimental): the blocks of the server's loaded chunks, and changes to them through the server's own block updates.
+
+### record `block-change`
+
+| Field | Type | |
+| --- | --- | --- |
+| `x` | `s32` |  |
+| `y` | `s32` |  |
+| `z` | `s32` |  |
+| `state` | `string` | `minecraft:oak_log[axis=y]`; properties left out take the block's defaults, `minecraft:stone` alone is the default state. |
+
+| Function | Signature | What it does |
+| --- | --- | --- |
+| `get-block` | `func(dimension: string, x: s32, y: s32, z: s32) -> option<string>` | The block state at a position in a dimension (`minecraft:overworld`, ...), as `minecraft:oak_log[axis=y]`, as of this call: none where the server has no chunk loaded there. |
+| `get-biome` | `func(dimension: string, x: s32, y: s32, z: s32) -> option<string>` | The biome at a position (`minecraft:plains`, ...), as the server stores it (one per 4 x 4 x 4 cell): none where no chunk is loaded. |
+| `set-blocks` | `func(dimension: string, blocks: list<block-change>) -> result<_, string>` | Sets blocks as `/setblock` does: the old block entity removed, neighbours and shapes updated, light, and every player told. Every state is checked now (an error queues nothing); the changes are made in order after this call returns, before that dimension's next tick; one in a chunk not loaded then is skipped. At most 4096 per call. |
+
 ## `server-events`
 
 Access: exported by the mod: the game calls it.
@@ -505,16 +697,6 @@ What the server calls in a server mod (manifest `api = "0.3"`, experimental). On
 
 `type player = player`
 
-### record `registration`
-
-| Field | Type | |
-| --- | --- | --- |
-| `commands` | `list<string>` | Commands players may type, without the slash. A name vanilla already uses is refused (vanilla's command runs). |
-| `tick` | `bool` | Call `tick` every server tick (20 per second). |
-| `joins` | `bool` | Call `player-joined` and `player-left`. |
-| `chat` | `bool` | Call `chat` for each chat message a player sends. |
-| `blocks` | `bool` | Call `block-broken` and `block-placed`. |
-
 ### record `block-pos`
 
 | Field | Type | |
@@ -523,6 +705,59 @@ What the server calls in a server mod (manifest `api = "0.3"`, experimental). On
 | `y` | `s32` |  |
 | `z` | `s32` |  |
 
+### variant `argument-kind`
+
+What an argument of a command takes. The server sends each command and its arguments to players' games, whose chat box completes and colours them as vanilla's; the server parses them before the mod's `command` hook gets their values.
+
+| Case | Payload | |
+| --- | --- | --- |
+| `word` |  | One word: letters, digits and `_ - . +`. |
+| `text` |  | The rest of the line, spaces included: only last. |
+| `integer` | `tuple<option<s32>, option<s32>>` | A whole number, within the bounds given. |
+| `number` |  | A number with or without decimals. |
+| `boolean` |  | `true` or `false`. |
+| `player` |  | One online player: a name, or `@s` or `@p` (whoever typed it, as vanilla picks for a player). |
+| `block-pos` |  | A block position: three whole numbers, each one also `~` or `~n`, relative to whoever typed it. |
+
+### record `argument`
+
+| Field | Type | |
+| --- | --- | --- |
+| `name` | `string` | Shown in the chat box's hint (`<height>`) and the key of its value. |
+| `kind` | `argument-kind` |  |
+| `optional` | `bool` | Optional arguments come after every required one. |
+
+### record `server-command`
+
+| Field | Type | |
+| --- | --- | --- |
+| `name` | `string` | Without the slash. A name vanilla already uses is refused (vanilla's command runs). |
+| `arguments` | `list<argument>` | In order; none: the command takes nothing after its name. Free text is one optional `text` argument. |
+
+### variant `argument-value`
+
+An argument's value, parsed as its kind says.
+
+| Case | Payload | |
+| --- | --- | --- |
+| `word` | `string` |  |
+| `text` | `string` |  |
+| `integer` | `s32` |  |
+| `number` | `f64` |  |
+| `boolean` | `bool` |  |
+| `player` | `player` |  |
+| `block-pos` | `block-pos` |  |
+
+### record `registration`
+
+| Field | Type | |
+| --- | --- | --- |
+| `commands` | `list<server-command>` | Commands players may type. |
+| `tick` | `bool` | Call `tick` every server tick (20 per second). |
+| `joins` | `bool` | Call `player-joined` and `player-left`. |
+| `chat` | `bool` | Call `chat` for each chat message a player sends. |
+| `blocks` | `bool` | Call `block-broken` and `block-placed`. |
+
 | Function | Signature | What it does |
 | --- | --- | --- |
 | `init` | `func() -> result<registration, string>` | Once, after loading. An error keeps the mod off and is logged. |
@@ -530,6 +765,6 @@ What the server calls in a server mod (manifest `api = "0.3"`, experimental). On
 | `player-joined` | `func(player: player)` | A player joined the server; they are in `players.online` already. |
 | `player-left` | `func(player: player)` | A player left the server; they are no longer in `players.online`. |
 | `chat` | `func(player: player, text: string)` | A chat message a player sent, as plain text. |
-| `command` | `func(player: player, name: string, args: string) -> result<option<string>, string>` | `/name args` typed by `player`: ok(some(text)) is their feedback, err(text) their error in red. |
+| `command` | `func(player: player, name: string, args: string, values: list<tuple<string, argument-value>>) -> result<option<string>, string>` | `/name args` typed by `player`: ok(some(text)) is their feedback, err(text) their error in red. `values` holds each argument given, by name, in order (an optional one left out isn't there); a line that doesn't parse never reaches the mod: the player gets vanilla's error. |
 | `block-broken` | `func(player: player, pos: block-pos, state: string)` | A player broke the block at `pos` in their dimension: `state` is what was there, as `minecraft:oak_log[axis=y]`. |
 | `block-placed` | `func(player: player, pos: block-pos, state: string)` | A player placed `state` at `pos` in their dimension. |
diff --git a/docs/api/mods.md b/docs/api/mods.md
index 1fc7a834e..55f890cc1 100644
--- a/docs/api/mods.md
+++ b/docs/api/mods.md
@@ -18,7 +18,7 @@ the player before the mod is turned on, and checked against the component's real
 | Hooks a mod exports | 5: `init`, `tick`, `frame`, `command`, `chat`; a server mod 8: `init`, `tick`, `player-joined`, `player-left`, `chat`, `command`, `block-broken`, `block-placed` |
 | Capabilities | 6: `game-read`, `chat`, `hud`, `storage`, `registries`, `players` |
 | Manifest `api` lines served | 3: `0.1` (code), `0.2` (content), `0.3` (server mods, experimental) |
-| SDK | the `Mod` trait (5 methods), `Registration` (4 builders), `export_mod!`, log helpers; `server::ServerMod` (8 methods), `server::Registration` (5 builders), `export_server_mod!` |
+| SDK | the `Mod` trait (5 methods), `Registration` (4 builders), `export_mod!`, log helpers; `server::ServerMod` (8 methods), `server::Registration` (6 builders), `server::Argument`, `server::Args`, `export_server_mod!` |
 | `cargo horizon-mod` | `new` (templates `code` and `content`), `build`, `run`, `test`, `check` |
 | Example mods | `coords-hud` (code), `ruby-content` (content), `welcome` (server) |
 
@@ -88,11 +88,11 @@ release.
 What real mods need next, in the order modpacks and servers need it:
 
 - **More for server mods** (`api = "0.3"`, [Server mods](../mods.md#server-mods-api-03-experimental)): they run
-  on the server thread, a LAN host and the dedicated server today, with joins, chat, commands and players' block
-  breaking and placing; next entity events, game rules, server commands with typed arguments sent to clients'
-  command trees.
-- **World and blocks**: read blocks, block states and biomes in loaded chunks; change them through the server's block
-  log, so clients and the parity harnesses see vanilla's updates.
+  on the server thread, a LAN host and the dedicated server today, with joins, chat, typed commands in players'
+  command trees, players' block breaking and placing, and `world` (read blocks and biomes, set blocks as `/setblock`
+  does); next entity events, game rules, entity, item and block-state arguments.
+- **World and blocks**: blocks, block states and biomes are there for server mods (`world`); next block entities,
+  and `world` for client mods (raycasts, single player and LAN hosts).
 - **Items and inventories**: the player's inventory, held item and open container; item stacks with components.
 - **Entities**: query and change entities near a position; spawn from a mod's own entity types (data first).
 - **Block entities and menus**: ticking machines with slots and their screens.
@@ -106,6 +106,11 @@ What real mods need next, in the order modpacks and servers need it:
 
 ## Changelog
 
+- API 0.3: typed server commands: `registration.commands` lists each command's arguments (`argument-kind`: word,
+  text, integer, number, boolean, player, block-pos), sent in players' command trees and parsed by the server;
+  `command` gets their values. SDK `Registration::command_with`, `Argument`, `Args`.
+- API 0.3: capability `world` (`get-block`, `get-biome`, `set-blocks`); example `beacons`; test scripts' `blocks` and
+  `expect.blocks`.
 - Server mods run in the game: single player (server thread and in-frame), LAN hosts, the dedicated server.
 - API 0.3 (server mods, experimental): world `horizon-server-mod`, capability `players`, the `server-events`
   hooks; SDK `server::ServerMod`; example `welcome`.
diff --git a/docs/api/stability.md b/docs/api/stability.md
index df2c1aeb3..765034b3d 100644
--- a/docs/api/stability.md
+++ b/docs/api/stability.md
@@ -38,7 +38,7 @@ don't import it); faster, or fixing behaviour to what the reference already says
 
 A new WIT function doesn't break older mods, but a mod that calls it can't run on a Horizon from before it. So every
 function the game offers mods has an **API level**, the one it arrived at (`crates/horizon-mods/src/api_level.rs`):
-level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`, level 3 `command.run-quiet`. A mod needs the level of
+level 0 is the contract of Horizon 0.2.67 to 0.2.69, level 1 adds `render.set-minimap` and server mods' `players`, level 2 `game.raycast`, level 3 `command.run-quiet`, level 4 server mods' `world`, level 5 `recipes` (`items`, `all`, `known`), level 6 `browser` (`set-items`, `poll`, `set-recipes`) and `recipes.place` and `recipes.give`, level 7 `render.set-far-terrain`. A mod needs the level of
 the newest function it imports (a component imports only the functions it calls). The level is read from the file,
 never declared:
 
@@ -108,7 +108,7 @@ Deprecations and breaking changes are in bold. The release notes of the game rel
 | Mod API: `render` (HUD shapes, camera shake and zoom; drawn by the game, no mod shaders) | experimental | manifest `experimental = ["render"]` |
 | Mod API: `input` (claimed items' use, the mod's keys, the mouse wheel) | experimental | manifest `experimental = ["input"]` |
 | Content mods (`registries`: data-driven blocks and items) | preview | manifest `api = "0.2"` |
-| Server mods: world `horizon-server-mod`, `players`, `server-events` | experimental | manifest `api = "0.3"` |
+| Server mods: world `horizon-server-mod`, `players`, `server-events`, `world`, typed `server-command`s | experimental | manifest `api = "0.3"` |
 | Script mods (Lua run by an interpreter mod, [mods.md](mods.md#ways-in)) | not started | |
 | `cargo horizon-mod` (`new`, `build`, `run`), `horizon-mod-sdk` | preview | 0.1.0 |
 | Shader API | not started | |
@@ -134,3 +134,8 @@ Deprecations and breaking changes are in bold. The release notes of the game rel
   for a map image costs too much through hook calls, so the game keeps the tiles (vanilla's map colours) and the mod
   picks the corner, side, scale and shape. One map shows at a time, the first loaded mod's. It is a new function and a
   new type, so mods built before it keep loading.
+- **`render.set-far-terrain`** turns on the game's own distant terrain, not one a mod builds: sampling the generator
+  and meshing thousands of far tiles runs on the game's workers within its frame and upload budgets, which no hook
+  call could match. The mod picks the distance (64 to 1024 chunks, capped lower on integrated graphics as LOD Distance
+  is) and Far Detail's Reduced. The player's own LOD Distance, when on, wins; one far terrain shows at a time, the
+  first loaded mod's.
diff --git a/docs/architecture.md b/docs/architecture.md
index 0350bd1ea..3aec2338b 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -5,8 +5,9 @@ counted only for the game loop because nearly every gameplay change touches it).
 organised and how to build and test are in [AGENTS.md](../AGENTS.md).
 
 Paths: `L/` = `crates/horizon-client/src/`, `G/` = `crates/horizon-client/src/game/`, `W/` =
-`crates/horizon-world/src/`. Checks: a bare name is a harness (`python3 tools/parity.py <name>`, script
-`tools/test_<name>_parity.py`); `lan_e2e <check>` is `python3 tools/lan_e2e.py --check <check>`.
+`crates/horizon-world/src/`, `K/` = `crates/horizon-client-core/src/`, `C/` = `crates/horizon-command/src/`.
+Checks: a bare name is a harness (`python3 tools/parity.py <name>`, script `tools/test_<name>_parity.py`);
+`lan_e2e <check>` is `python3 tools/lan_e2e.py --check <check>`.
 
 For the full set of harnesses a file can affect, ask the runner:
 `printf '%s\n' <paths> > /tmp/p.txt && python3 tools/parity.py --changed-files /tmp/p.txt --list`.
@@ -17,7 +18,7 @@ file selects ~103.
 |---|---|---|---|
 | 1 | Game loop, tick order, frame pacing (554) | `L/game.rs` (`fn tick`, `fn tick_world`, `fn render`, `about_to_wait`), `L/clock.rs`, `L/window.rs`, `L/spans.rs` | game_loop, frame_limiter, interaction_input, tick |
 | 2 | Mobs in the game loop, spawning (166) | `G/creatures.rs`, `G/natural_spawning.rs`, `L/mobs/spawning.rs`, `L/mobs/spawn_rules.rs`, `L/mobs/spawn_selection.rs`, `L/mobs/finalize.rs`, `G/spawner.rs`, `G/trial_spawner.rs` | natural_spawn, spawn_rules, finalize_spawn, spawner, trial_spawner, mob_ai |
-| 3 | World save and load (163) | `L/save.rs`, `G/saving.rs`, `G/persist.rs` (entities), `L/entity_nbt.rs`, `L/block_entity_nbt.rs`, `W/region.rs`, `W/nbt.rs` | save_roundtrip, world_reopen, world, datafix |
+| 3 | World save and load (163) | `L/save.rs`, `G/saving.rs`, `G/persist.rs` (entities), `L/entity_nbt.rs`, `K/block_entity_nbt.rs`, `W/region.rs`, `W/nbt.rs` | save_roundtrip, world_reopen, world, datafix |
 | 4 | World generation (153) | `W/worldgen.rs`, `W/worldgen/` (`generator*.rs`, `feature_graph.rs`, `structure/`, `placement/`), `L/vanillagen.rs` | chunk_generation, worldgen, server_world_gen, world_spawn, feature_graph, feature_placement, decoration and the other worldgen harnesses |
 | 5 | Multiplayer client, packets in (145) | `G/remote.rs` (`fn handle_packet`, `fn tick_remote`), `G/remote_*.rs`, `L/net.rs` | dedicated_server, server_entities, lan_e2e (all) |
 | 6 | Agent control, horizon-ctl (145) | `L/control.rs`, `L/bin/horizon-ctl/`, `G/control.rs`, `G/agent.rs`, `G/events.rs`, `G/ui_control.rs` | `python3 tools/agent_control_e2e.py`; `cargo test -p horizon-client --bin horizon-ctl` |
@@ -32,7 +33,7 @@ file selects ~103.
 | 15 | Items and item use (96) | `L/items.rs`, `L/item_data.rs`, `G/hand.rs`, `G/consume.rs`, `G/potions.rs`, `L/effects.rs`; game.rs `fn use_hand`, `fn use_item` | use_item_on, item_use, item_use_lifecycle, consumable, consume_effect, status_effect |
 | 16 | Options and settings screens (93) | `L/options_ui.rs`, `G/options.rs`, `L/settings.rs`, `L/options_file.rs`, `L/graphics_ui.rs`, `L/graphics.rs` | options, toggle_keys |
 | 17 | HUD, chat, tab list (93) | `L/hud.rs`, `L/hud_layout.rs`, `L/hud_overlays.rs`, `L/chat.rs`, `G/chat.rs`, `L/tab_list.rs`, `L/locator_bar.rs`, `G/locator_bar.rs` | hud, tab_list, locator_bar, chat_screen, secure_chat |
-| 18 | Command execution (88) | `G/commands.rs`, `G/commands/*.rs`, `L/scoreboard_cmd.rs`, `L/data_cmd.rs`, `G/functions.rs` | command_exec (corpus `tools/command_exec_corpus.py`), scoreboard, server_ops_feedback, lan_e2e commands |
+| 18 | Command execution (88) | `G/commands.rs`, `G/commands/*.rs`, `L/scoreboard_cmd.rs`, `L/data_cmd.rs`, `K/scoreboard.rs`, `G/functions.rs` | command_exec (corpus `tools/command_exec_corpus.py`), scoreboard, server_ops_feedback, lan_e2e commands |
 | 19 | Chunk streaming, light, tickets (85) | `L/streaming.rs`, `L/world.rs`, `L/chunk.rs`, `L/chunk_map.rs`, `L/light.rs`, `L/ticket_levels.rs`, `L/tick_chunk_membership.rs`, `G/world_loading.rs` | light, chunk_status, random_tick_sections; `cargo test -p horizon-client --test streaming_meshes` |
 | 20 | Mob models and animation (78) | `L/mobs/render.rs`, `L/mobs/anim.rs`, `L/mobs/body_anim.rs`, `L/mobs/keyframes.rs`, `L/entity.wgsl` | entity_model |
 | 21 | Block behaviour, server side (78) | `W/level/` (`mod.rs`, `tick.rs`, `hooks.rs`, `data.rs`, `redstone.rs`, `place.rs`), `G/block_entity_ticks.rs`, `G/moving_pistons.rs` | block_update, redstone, random_tick, simple_block, piston_movement, block_entity_tickers |
@@ -46,12 +47,12 @@ file selects ~103.
 | 29 | Title, worlds, startup (49) | `L/title.rs` + `L/title/`, `G/startup_menu.rs`, `L/title_edition.rs` | world_options; `cargo test -p horizon-client --lib title` |
 | 30 | Dedicated server, horizon-server (48) | `G/dedicated.rs`, `G/dedicated/status.rs`, `crates/horizon-server/`, `crates/horizon-server-files/` | dedicated_server, server_files, user_cache, online_mode, server_ops_feedback |
 | 31 | Particles and client effects (46) | `L/particles.rs`, `G/render_tick.rs`, `G/level_particles.rs`, `L/animate_tick.rs` | particle_providers, block_particles, entity_particles, emitter_particles, marker_particles |
-| 32 | Bosses and the End (45) | `G/dragon.rs`, `G/wither.rs`, `G/end.rs` | server_dragon, end_podium, end_gateway |
+| 32 | Bosses and the End (45) | `G/dragon.rs`, `G/wither.rs`, `G/end.rs` | server_dragon, forced_end, end_podium, end_gateway |
 | 33 | Protocol and packets (44) | `crates/horizon-protocol/src/` (`packets/play.rs`, `entity_data.rs`, `connection.rs`) | dedicated_server, online_mode, secure_chat; `cargo test -p horizon-protocol` |
 | 34 | Multiplayer and LAN screens, friends (44) | `L/multiplayer.rs`, `G/lan_screen.rs`, `G/friends.rs`, `L/friends_screen.rs`, `crates/horizon-friends/`, `crates/horizon-relay/` | lan, world_options; `python3 tools/test_friends.py` |
 | 35 | Dispensers (43) | `G/dispenser.rs`, `G/dispense_fixture.rs` (the harness side) | dispenser |
 | 36 | Audio and music (38) | `L/audio.rs`, `L/sound_engine.rs`, `L/sound_events.rs`, `L/music.rs`, `G/music.rs`, `L/ambience.rs`, `G/subtitle_hud.rs` | sound_engine, sound_event, music, situational_music, ambient_sound, subtitle |
 | 37 | Integrated server and levels (34) | `G/integrated.rs`, `G/levels.rs`, `G/server_travel.rs` | server_dimension_players, `lan_e2e` (server-thread by default; portals, levels, distance, lava) |
-| 38 | Command parsing (34) | `L/command/` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`) | command_parse (corpus `tools/command_parse_corpus.py`) |
+| 38 | Command parsing (34) | `C/` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`); `cargo test -p horizon-command` | command_parse (corpus `tools/command_parse_corpus.py`) |
 | 39 | Benchmarks and telemetry (34) | `L/benchmark.rs`, `tools/perf_bench.py`, `L/telemetry.rs`, `crates/horizon-telemetry*/`, `crates/horizon-bench/` | `python3 -m unittest tests.test_perf_bench`; [benchmark.md](benchmark.md) |
 | 40 | Explosions and TNT (31) | `G/explosion.rs`, `G/tnt.rs` | lan_e2e blast; no dedicated harness yet |
diff --git a/docs/design-system.md b/docs/design-system.md
index 0b171d4c2..aec060457 100644
--- a/docs/design-system.md
+++ b/docs/design-system.md
@@ -170,9 +170,12 @@ of the main action. The game's menus keep `LIGHT` and `DARK`.
   all rights reserved, so it is not shown.
 - **Partner banner**: the one exception to shipping no third-party pictures. Sculk, a server host,
   sponsors Horizon: its banner (`launcher/assets/sculk-banner.webp`, `launcher/src/partner.rs`) sits
-  under a muted mono "Partner" label at the end of the Servers page and of Home, below Play, and opens
-  Sculk's page in the browser. The website shows the same banner the same way on Home and the hosting
-  docs, as a `rel="sponsored"` link.
+  under a muted mono "Partner" label at the end of the Servers page and opens Sculk's page in the
+  browser. The sidebar of the other pages shows a card made for its width instead: Sculk's characters
+  and logo cropped from the same banner, and the text drawn by the launcher in its language, so it
+  stays readable; it keeps Sculk's dark card, cyan and rounded corners in both themes, as an ad does,
+  and turns compact (characters beside the text) when the window is too short. The website shows the
+  banner the same way on Home and the hosting docs, as a `rel="sponsored"` link.
 - **Pixel art drawn in code.** The stone behind the pages is close shades of the page colour
   (`TILE_SHADES`), never Minecraft's stone; the landscape is a banded sky, a sun cut in slices like
   the mark, hills and square trees (a sunset in dark, a dawn in light). The launcher bakes them in
diff --git a/docs/graphics.md b/docs/graphics.md
index dcba29773..f7deed8f6 100644
--- a/docs/graphics.md
+++ b/docs/graphics.md
@@ -29,7 +29,7 @@ Every row has a one-line description and its cost in frame time (none, low, medi
 
 **Battery mode** (Performance, off by default) is for laptops and handhelds: at most 60 frames per second in a world, 30 in menus without a world or while another window has focus, and half the automatic worker threads (chunks load slower). It changes only when frames are drawn: what they show and the game's 20 ticks per second stay as they are.
 
-**HDR** (Display, off by default) presents to an scRGB swapchain (`Rgba16Float`, extended linear sRGB) on displays and compositors that offer it. The frame is drawn exactly as in SDR, in vanilla's gamma space, and a last pass (`hdr.wgsl`) decodes it to linear light at the **Paper White** and lifts light sources (blocks that emit light, lava, the sun and the moon) towards the **Peak Brightness**; everything else stays as in SDR. The mesher puts the light a block's face emits in its vertex colour's alpha (`EMISSION_BITS`), the frame's alpha carries the mark, and only pixels that still show the world before the hand and HUD are lifted. On Vulkan, `horizon-hdr` sends HDR metadata (MaxCLL, mastering luminance), which wgpu doesn't: without it a compositor may clip everything above SDR white. KWin maps the content's reference white onto the desktop's SDR brightness, so on Linux the default Paper White matches SDR mode. `HORIZON_HDR_DEBUG=1` paints lifted pixels magenta. Not lifted yet: glowing particles, distant LOD terrain.
+**HDR** (Display, off by default) presents to an HDR10 swapchain (`Rgb10a2Unorm`, BT.2020 with the PQ curve) or, where only that is offered, an scRGB one (`Rgba16Float`, extended linear sRGB), on displays and compositors that offer either; `HORIZON_HDR_OUTPUT=pq` or `scrgb` allows only one. The frame is drawn exactly as in SDR, in vanilla's gamma space, and a last pass (`hdr.wgsl`) decodes it to linear light at the **Paper White** and lifts light sources (blocks that emit light, lava, the sun and the moon) towards the **Peak Brightness**; everything else stays as in SDR. The mesher puts the light a block's face emits in its vertex colour's alpha (`EMISSION_BITS`), the frame's alpha carries the mark, and only pixels that still show the world before the hand and HUD are lifted. On Vulkan, `horizon-hdr` sends HDR metadata (MaxCLL, mastering luminance), which wgpu doesn't: without it a compositor may clip everything above SDR white. KWin maps the content's reference white onto the desktop's SDR brightness, so on Linux the default Paper White matches SDR mode. `HORIZON_HDR_DEBUG=1` paints lifted pixels magenta. Not lifted yet: glowing particles, distant LOD terrain.
 
 Which settings each screen shows, their descriptions and costs are in `crates/horizon-client/src/graphics_ui.rs` (`rows`); `graphics_style.rs` draws them.
 
@@ -47,7 +47,7 @@ Coverage and detail improve progressively; a large selected radius does not mean
 
 Ordinary Overworld atmospheric fog extends with the selected LOD distance. Fog Off disables distance haze at large ranges too; fluid, darkness and boss fog retain their limits.
 
-The setting is stored as `lodDistance` in `horizon-graphics.txt`; `0` disables it. Existing `renderDistance` in `options.txt` keeps its normal meaning for full chunks.
+The setting is stored as `lodDistance` in `horizon-graphics.txt`; `0` disables it. The official Far View mod (`mods/official/far-view`, [mods.md](mods.md)) turns the same distant terrain on from the mod browser, with its own distance and detail; the setting, when on, wins. Existing `renderDistance` in `options.txt` keeps its normal meaning for full chunks.
 
 Not implemented: anisotropic filtering (wgpu needs linear magnification for it, which blurs close blocks), MSAA (FXAA instead) and exclusive fullscreen (fullscreen is borderless).
 
diff --git a/docs/launcher-commands.md b/docs/launcher-commands.md
index 1e9fb7722..900a10283 100644
--- a/docs/launcher-commands.md
+++ b/docs/launcher-commands.md
@@ -50,9 +50,11 @@ Start the client.
 
     horizon-launcher play
 
+- `--instance`: The instance to play (its name or id; default: the selected one)
 - `--world`: Open or create this world (a folder under saves) at once
 - `--creative`: Creative mode for a new world
 - `--join`: Join a friend's world with its invite code
+- `--server`: Join this server at once: an address, or a server of the list by name or position
 - `--arg`: An extra argument for the game, passed through as-is (repeatable), for example --server-thread
 
 MCP: `play`, then the `game_*` tools.
@@ -114,7 +116,7 @@ MCP: `account_sign_out`, needs `confirm: true`.
 
 ## `horizon-launcher account select`
 
-Play as this account.
+Play as this account, or as one of your offline names.
 
     horizon-launcher account select <WHO>
 
@@ -124,19 +126,46 @@ MCP: `account_select`.
 
 ## `horizon-launcher account offline`
 
-Play offline, without an account.
+Play offline, without an account: as NAME (kept to switch back to; 3 to 16 letters, digits or _), or as the name the game made up.
 
-    horizon-launcher account offline
+    horizon-launcher account offline [NAME]
+
+- `NAME`
 
 MCP: `account_offline`.
 
+## `horizon-launcher account forget-offline`
+
+Forget one of your offline names.
+
+    horizon-launcher account forget-offline <NAME>
+
+- `NAME`
+
+MCP: `account_forget_offline`.
+
+## `horizon-launcher account skin`
+
+Show or set an offline name's skin and cape: a 64x64 (or 64x32) skin PNG, a 64x32 cape PNG, the model. Kept by the launcher and given to the game when that name plays.
+
+    horizon-launcher account skin <NAME> [FILE]
+
+- `NAME`
+- `FILE`: The skin's PNG
+- `--model`: classic or slim arms
+- `--cape`: The cape's PNG
+- `--no-skin`: Back to the default skin
+- `--no-cape`: Take the cape off
+
+MCP: `account_skin`.
+
 ## `horizon-launcher settings`
 
-Show the launcher's settings, or set one (the Settings page): selected-version TAG, minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions on|off, opening-animation on|off, proxy http://host:port ("default" removes it).
+Show the launcher's settings, or set one (the Settings page): selected-version TAG, minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions on|off, opening-animation on|off, proxy http://host:port ("default" removes it), while-playing stay|minimize|hide (what the window does while the game runs), language system|en|fr|ru (the window's language; system follows the computer's), accent violet|blue|teal|green|amber|red|pink, background PATH (a picture behind Home; "default" shows Horizon's landscape).
 
     horizon-launcher settings [KEY] [VALUE]
 
-- `KEY` (selected-version, minecraft-dir, server-dir, install-new-versions, opening-animation, proxy)
+- `KEY` (selected-version, minecraft-dir, server-dir, install-new-versions, opening-animation, proxy, while-playing, language, accent, background)
 - `VALUE`: The new value (with KEY)
 
 MCP: `settings`.
@@ -151,6 +180,26 @@ Show or set the extra arguments the game starts with (for example --server-threa
 
 MCP: `game_args`.
 
+## `horizon-launcher share-log`
+
+Upload an instance's latest.log to mclo.gs (a paste service for Minecraft logs) and print its link, for a bug report: only when the player asks. The home folder, the user name and the account names are taken out first; the link expires after 90 days unread.
+
+    horizon-launcher share-log
+
+- `--instance`: The instance (default: the selected one)
+
+MCP: `share_log`, only when the player asks.
+
+## `horizon-launcher unshare-log`
+
+Delete a log shared with share-log: the "<id>:<token>" it printed.
+
+    horizon-launcher unshare-log <SHARED>
+
+- `SHARED`
+
+MCP: `unshare_log`, needs `confirm: true`.
+
 ## `horizon-launcher logs`
 
 Print the end of the game's log (logs/latest.log in the game folder), or its newest crash report.
@@ -257,6 +306,319 @@ Upload a benchmark report (docs/benchmark-report.md); it is printed first.
 
 MCP: `data_benchmark`, only when the player asks.
 
+## `horizon-launcher instance list`
+
+The instances, each with its game folder (* = the one Play starts).
+
+    horizon-launcher instance list
+
+MCP: `instance_list`.
+
+## `horizon-launcher instance create`
+
+Make an instance: empty but for your options and name, or a copy of another one's worlds, options and packs.
+
+    horizon-launcher instance create <NAME>
+
+- `NAME`
+- `--copy`: The instance to copy (its name or id)
+
+MCP: `instance_create`.
+
+## `horizon-launcher instance rename`
+
+Rename an instance (its folder stays).
+
+    horizon-launcher instance rename <INSTANCE> <NAME>
+
+- `INSTANCE`
+- `NAME`
+
+MCP: `instance_rename`.
+
+## `horizon-launcher instance icon`
+
+Set an instance's icon: a block or item name from your prepared files (grass_block), a colour (#3fa7d6), or none.
+
+    horizon-launcher instance icon <INSTANCE> <ICON>
+
+- `INSTANCE`
+- `ICON`
+
+MCP: `instance_icon`.
+
+## `horizon-launcher instance group`
+
+Put an instance in a sidebar group, or take it out with no group.
+
+    horizon-launcher instance group <INSTANCE> [GROUP]
+
+- `INSTANCE`
+- `GROUP`
+
+MCP: `instance_group`.
+
+## `horizon-launcher instance select`
+
+Make Play start this instance.
+
+    horizon-launcher instance select <INSTANCE>
+
+- `INSTANCE`
+
+MCP: `instance_select`.
+
+## `horizon-launcher instance version`
+
+Keep an instance on one installed Horizon version, or "latest" to follow updates again.
+
+    horizon-launcher instance version <INSTANCE> <VERSION>
+
+- `INSTANCE`
+
+MCP: `instance_version`.
+
+## `horizon-launcher instance export`
+
+Export an instance (or a port) to share: its settings, packs, Horizon mods and the worlds named, as a .mrpack (resource packs from Modrinth listed by download) or a zip. Never logs, screenshots or account data; worlds go without their per-player files.
+
+    horizon-launcher instance export [INSTANCE]
+
+- `INSTANCE`: The instance (default: the selected one)
+- `--format` (mrpack, zip)
+- `--world`: A world to put in it (its name or folder); repeat for more
+- `--out`: Where to write it (default: "<name>.mrpack" in the current folder)
+
+MCP: `instance_export`.
+
+## `horizon-launcher instance launch`
+
+Show or set what runs around an instance's game: a shell command before it (the game starts only if it succeeds), a wrapper it runs through (`nice -n 5`), and environment variables ("NAME=value NAME2=value"). An empty value clears one. On Linux, also GameMode, MangoHud and the dedicated graphics card, when the computer has them.
+
+    horizon-launcher instance launch <INSTANCE>
+
+- `INSTANCE`
+- `--pre-launch`
+- `--wrapper`
+- `--env`
+- `--gamemode`: Linux: run it through GameMode (gamemoderun), on or off
+- `--mangohud`: Linux: MangoHud's overlay, on or off
+- `--dedicated-gpu`: Linux: the dedicated graphics card (DRI_PRIME, or NVIDIA's offload), on or off
+
+MCP: `instance_launch`, needs `confirm: true`.
+
+## `horizon-launcher instance shortcut`
+
+Put a shortcut on the desktop that plays an instance (`play --instance`): a .desktop file (also in the applications menu) on Linux, an app on macOS, a .lnk on Windows.
+
+    horizon-launcher instance shortcut [INSTANCE]
+
+- `INSTANCE`: The instance (default: the selected one)
+- `--remove`: Move the instance's shortcuts to the trash instead
+
+MCP: `instance_shortcut`.
+
+## `horizon-launcher instance import`
+
+Import what a file is, as dropping it on the window does: a shared instance (a .mrpack without mod loaders, such as `instance export` writes, or a game folder zip) becomes a new instance; a Java modpack goes to the Modpacks import; a resource or shader pack into the instance (default: the selected one).
+
+    horizon-launcher instance import <FILE>
+
+- `FILE`
+- `--instance`: The instance a pack goes into
+
+MCP: `instance_import`.
+
+## `horizon-launcher worlds list`
+
+The worlds: name, mode, version, last played and size (the default).
+
+    horizon-launcher worlds list
+
+- `--instance`: The instance (default: the selected one)
+
+MCP: `worlds_list`.
+
+## `horizon-launcher worlds backup`
+
+Zip a world into the instance's backups/ folder, as the game's Make Backup does.
+
+    horizon-launcher worlds backup <WORLD>
+
+- `WORLD`: Its folder or name
+- `--instance`
+
+MCP: `worlds_backup`.
+
+## `horizon-launcher worlds copy`
+
+Copy a world beside it, as "<name> (1)".
+
+    horizon-launcher worlds copy <WORLD>
+
+- `WORLD`
+- `--instance`
+
+MCP: `worlds_copy`.
+
+## `horizon-launcher worlds delete`
+
+Move a world to the system's trash.
+
+    horizon-launcher worlds delete <WORLD>
+
+- `WORLD`
+- `--instance`
+
+MCP: `worlds_delete`, needs `confirm: true`.
+
+## `horizon-launcher worlds datapack-list`
+
+A world's data packs, and which are on.
+
+    horizon-launcher worlds datapack-list <WORLD>
+
+- `WORLD`
+- `--instance`
+
+MCP: `worlds_datapack_list`.
+
+## `horizon-launcher worlds datapack-add`
+
+Copy a data pack zip into a world (the game turns it on when the world opens).
+
+    horizon-launcher worlds datapack-add <WORLD> <FILE>
+
+- `WORLD`
+- `FILE`
+- `--instance`
+
+MCP: `worlds_datapack_add`.
+
+## `horizon-launcher worlds datapack-remove`
+
+Move a world's data pack to the system's trash.
+
+    horizon-launcher worlds datapack-remove <WORLD> <PACK>
+
+- `WORLD`
+- `PACK`: Its file name, with or without .zip
+- `--instance`
+
+MCP: `worlds_datapack_remove`, needs `confirm: true`.
+
+## `horizon-launcher packs list`
+
+The resource and shader packs, and which are on (the default).
+
+    horizon-launcher packs list
+
+- `--kind` (resource, shader): Only this kind
+- `--instance`: The instance (default: the selected one)
+
+MCP: `packs_list`.
+
+## `horizon-launcher packs add`
+
+Copy a pack file in: a resource pack .zip, a shader pack .zip or a .hshader.
+
+    horizon-launcher packs add <FILE>
+
+- `FILE`
+- `--instance`
+
+MCP: `packs_add`.
+
+## `horizon-launcher packs on`
+
+Turn a pack on (a resource pack goes on top; a shader pack replaces the one that was on).
+
+    horizon-launcher packs on <PACK>
+
+- `PACK`: Its file name or title
+- `--kind` (resource, shader)
+- `--instance`
+
+MCP: `packs_on`.
+
+## `horizon-launcher packs off`
+
+Turn a pack off.
+
+    horizon-launcher packs off <PACK>
+
+- `PACK`
+- `--kind` (resource, shader)
+- `--instance`
+
+MCP: `packs_off`.
+
+## `horizon-launcher packs remove`
+
+Turn a pack off and move it to the system's trash.
+
+    horizon-launcher packs remove <PACK>
+
+- `PACK`
+- `--kind` (resource, shader)
+- `--instance`
+
+MCP: `packs_remove`, needs `confirm: true`.
+
+## `horizon-launcher screenshots list`
+
+The screenshots, the newest first, with their files (the default).
+
+    horizon-launcher screenshots list
+
+- `--instance`: The instance (default: the selected one)
+
+MCP: `screenshots_list`.
+
+## `horizon-launcher screenshots delete`
+
+Move a screenshot to the system's trash.
+
+    horizon-launcher screenshots delete <SCREENSHOT>
+
+- `SCREENSHOT`: Its file name, with or without .png
+- `--instance`
+
+MCP: `screenshots_delete`, needs `confirm: true`.
+
+## `horizon-launcher multiplayer list`
+
+The servers of the game's Multiplayer screen (the default).
+
+    horizon-launcher multiplayer list
+
+- `--instance`: The instance (default: the selected one)
+
+MCP: `multiplayer_list`.
+
+## `horizon-launcher multiplayer add`
+
+Add a server to the list.
+
+    horizon-launcher multiplayer add <ADDRESS>
+
+- `ADDRESS`: Its address, as in the game's Add Server (host or host:port)
+- `--name`: Its name in the list (default: Minecraft Server)
+- `--instance`
+
+MCP: `multiplayer_add`.
+
+## `horizon-launcher multiplayer remove`
+
+Remove a server from the list: its position from 1, name or address.
+
+    horizon-launcher multiplayer remove <SERVER>
+
+- `SERVER`
+- `--instance`
+
+MCP: `multiplayer_remove`, needs `confirm: true`.
+
 ## `horizon-launcher modpack list`
 
 The imported packs and their coverage (the default).
@@ -308,10 +670,12 @@ MCP: `modpack_remove`, needs `confirm: true`.
 
 ## `horizon-launcher mods list`
 
-What the browser installed (the default).
+What the browser installed in an instance (the default).
 
     horizon-launcher mods list
 
+- `--instance`: The instance (default: the selected one)
+
 MCP: `mods_list`.
 
 ## `horizon-launcher mods search`
@@ -321,7 +685,7 @@ Search for packs Horizon loads.
     horizon-launcher mods search [TEXT]...
 
 - `TEXT`
-- `--kind` (mod, resource, modpack, shader)
+- `--kind` (mod, resource, modpack, shader, datapack)
 - `--everything`: Also what was made for other versions or runs only partly, each marked
 - `--source` (modrinth, curseforge, horizon)
 
@@ -341,11 +705,13 @@ MCP: `mods_check`.
 
 ## `horizon-launcher mods install`
 
-Install a pack and what it needs, by its id or slug (checksums checked); a Java mod is ported into horizon-mods and turned on; a modpack is imported.
+Install a pack and what it needs into an instance, by its id or slug (checksums checked); a Java mod is ported into horizon-mods and turned on; a modpack is imported as an instance of its own; a data pack goes into the world `--world` names.
 
     horizon-launcher mods install <PROJECT>
 
 - `PROJECT`
+- `--world`: Install the project's data pack into this world of the instance (its name or folder)
+- `--instance`: The instance (default: the selected one)
 - `--everything`: Allow a version made for another Minecraft version
 - `--source` (modrinth, curseforge, horizon)
 
@@ -359,6 +725,7 @@ Update what the browser installed (or one pack).
 
 - `PROJECT`
 - `--check`: Only say what is newer
+- `--instance`: The instance (default: the selected one)
 
 MCP: `mods_update`.
 
@@ -369,6 +736,7 @@ Remove a pack the browser installed.
     horizon-launcher mods remove <PROJECT>
 
 - `PROJECT`
+- `--instance`: The instance (default: the selected one)
 
 MCP: `mods_remove`, needs `confirm: true`.
 
@@ -379,6 +747,7 @@ Turn on a mod the browser installed (horizon-mods.txt, as the game's Options > M
     horizon-launcher mods enable <PROJECT>
 
 - `PROJECT`
+- `--instance`: The instance (default: the selected one)
 
 MCP: `mods_enable`.
 
@@ -389,6 +758,7 @@ Turn off a mod the browser installed; it stays installed.
     horizon-launcher mods disable <PROJECT>
 
 - `PROJECT`
+- `--instance`: The instance (default: the selected one)
 
 MCP: `mods_disable`.
 
diff --git a/docs/mod-browser.md b/docs/mod-browser.md
index dfdd1617d..8db26c26a 100644
--- a/docs/mod-browser.md
+++ b/docs/mod-browser.md
@@ -1,6 +1,6 @@
 # The launcher's mod browser
 
-Search Modrinth (CurseForge support is coming soon) for Java mods, modpacks and resource packs, and Horizon's
+Search Modrinth (CurseForge support is coming soon) for Java mods, modpacks, resource packs and data packs, and Horizon's
 registry for Horizon's own mods, modpacks, resource packs and shader packs; see how well each one runs before installing it, and install it with its checksum checked. This is item 16 of the roadmap and issue #577. The code is in
 `launcher/src/browser.rs` and `launcher/src/browser/`.
 
@@ -17,6 +17,12 @@ yet (Modrinth has no `horizon` loader).
 | Resource packs | `resourcepacks/` beside `options.txt` | **Works** when made for 26.3 ([resource-packs.md](resource-packs.md) lists what Horizon reads). Older packs are **Partly**: they load with vanilla's compatibility warning |
 | Modpacks (`.mrpack`, CurseForge zip) | the Modpacks page's import | **Partly**: Horizon runs the mods it can port, from the player's own downloads ([modpacks.md](modpacks.md)) |
 | Shader packs (`.hshader`, Horizon's registry only) | `shaderpacks/` beside `options.txt` | **Works** when made for 26.3: checked by the game's own check before install ([shaders.md](shaders.md)). The `shaders/`-format packs on Modrinth and CurseForge are not offered |
+| Data packs (Modrinth) | `datapacks/` of the world picked on the **Data packs** tab (`mods install <pack> --world <world>`); not in the Installed list: each world's list on Home has them | **Partly**: Horizon runs a data pack's functions, function tags, predicates and item modifiers, not yet its recipes, loot tables, advancements, other tags or worldgen. The install reads the zip and says what of it runs; a pack with none of those (worldgen only, such as Tectonic) is refused |
+
+Mods, resource packs and shader packs go into the game folder of the instance selected in the sidebar, and the
+Installed list, updates and Remove are that instance's: picking another instance reads its list. The page says which
+instance it installs into when there is more than one. The CLI's `mods list|install|update|remove|enable|disable` take
+`--instance <name>` (default: the selected one). A modpack becomes an instance of its own.
 
 By default a search shows only what runs: Java mods made for 26.3, resource packs made for 26.3, and every modpack. **Show everything** lists the rest of the kind too, each marked with how well it runs; what doesn't run is
 never offered for install.
@@ -82,7 +88,8 @@ downloads, source and licence, how well it runs (and why), **Page** (the project
 **Install** (**Import** for a modpack). The Modpacks tab lists the imported packs first, with their coverage
 report, **Port** and **Play** ([modpacks.md](modpacks.md)). Installed packs are listed above the results with their version, source,
 file and the checksum they were checked against, with **Update to …** when a newer version runs and **Remove**
-(asked twice).
+(asked twice). **Update all (N)** above the list updates every pack a newer version was found for, of every kind,
+one after the other; one that fails is named and doesn't stop the others.
 
 ### Project pages, filters and icons
 
@@ -130,6 +137,7 @@ same name the player put there is never overwritten.
   pack still has to be turned on in the game's Resource Packs screen, as in vanilla, and a shader pack picked in
   the game's Shader Packs page.
 - **Update** installs the newer version and removes the old file.
+- **Update all** does the same for each pack with a newer version (`horizon-launcher mods update` with no pack name).
 - **Remove** deletes the file and its entry. Packs installed as dependencies stay.
 - **A modpack** is downloaded (checked the same way) into `ports/downloads/`, imported, and ported straight away
   for the selected version when it is prepared (`modpacks::import_and_port`): the jars of the mods Horizon can carry
diff --git a/docs/mods.md b/docs/mods.md
index a68b6d123..c6c30abea 100644
--- a/docs/mods.md
+++ b/docs/mods.md
@@ -15,7 +15,7 @@ folder, loads no runtime and plays exactly like vanilla 26.3.
 | The contract (WIT) | `crates/horizon-mod-sdk/wit/horizon.wit` | 0.1: log, game-read, chat, hud, storage, command, ui; tick, frame, chat and command hooks |
 | SDK for mod authors | `crates/horizon-mod-sdk` | 0.1 |
 | Example mods | `crates/horizon-mod-sdk/examples/coords-hud`, `examples/predator-missile` | coordinates, facing and time HUD, `/where`, `/coords`; `/missile`, a guided missile from vanilla commands |
-| Horizon's official mods | `mods/official/` | the extras moving to the registry: FPS Counter (`fps-overlay`), Keystrokes, Zoom, Minimap |
+| Horizon's official mods | `mods/official/` | the extras moving to the registry: FPS Counter (`fps-overlay`), Keystrokes, Zoom, Minimap; Far View (`far-view`), distant terrain; and Recipes, a recipe viewer |
 | Runtime | `crates/horizon-mods` | wasmtime 48 LTS, component model |
 | Authoring tool | `crates/cargo-horizon-mod` | `cargo horizon-mod new [--template code\|content] / build / run / test / check`, and the registry's CI (`registry build / review / list`) |
 | In the game | `crates/horizon-client/src/game/mods.rs`, Options > Mods | client mods |
@@ -88,9 +88,10 @@ folder, loads no runtime and plays exactly like vanilla 26.3.
 | `hud` | `hud` | `set-panel(corner, lines)`, `clear()`: up to 16 lines of 256 characters |
 | `storage` | `storage` | `get(key)`, `set(key, value)`, `delete(key)`: a per-mod folder of up to 64 files, 4 MiB total, at most 1 MiB written per call |
 | `command` | `command` | `run(line)`: a vanilla command run as the player, with the player's permissions, after the hook returns (8 per call); mods' own commands are not run. `run-quiet(lines)`: up to 256 a call, the same rights, nothing in the chat (single player and Horizon's servers run them 64 a tick and log one line a batch; elsewhere they go as chat commands and their feedback shows) |
-| `ui` | `ui` | `open-screen`, `close-screen`, `set-settings`: a screen the mod owns and a page in Options > Mods, of text, button, item and list widgets the game lays out and draws with its own menus' code. **Experimental:** the manifest needs `experimental = ["ui"]` |
-| `render` | `render` | `set-hud(shapes)`: up to 1024 fills, four-cornered shapes, GUI sprites, items and text, kept on the HUD (over the hotbar, under chat and screens, hidden with F1) until replaced; `set-corner(corner, w, h, shapes)`: a box the game places in a corner, stacked with its overlays and other panels, as `hud`'s panels are; `text-width(text)`; `frame-stats()`: the game's FPS, min and 1% low; `gui-size()`; `shake(strength, seconds)`: the view turns, the player doesn't, scaled by Distortion Effects; `set-zoom(zoom)`: the field of view divided by up to 10, eased or at once, with slower turning, while playing and not through a spyglass (the strongest of several mods' zooms counts); `set-minimap(minimap)`: a map of the world around the player in a corner, as a map item colours it (the floor underground and under roofs), square or round, turning with the player or north up, with the player's arrow; the game keeps its tiles within its own frame budget (one map at a time, the first loaded mod's). The game's own HUD renderer draws them: a mod never supplies shader code. **Experimental:** `experimental = ["render"]` |
+| `ui` | `ui` | `open-screen`, `close-screen`, `set-settings`: a screen the mod owns and a page in Options > Mods, of text, button, item and list widgets the game lays out and draws with its own menus' code; `browser.set-items`, `browser.poll`: a recipe viewer's panel of items right of the inventory and container screens (not the creative one), which the game pages and draws with its own slots and search box, and the mod hears its clicks, its searches and the mod's own keys (`input.register-key`) pressed over any item on the screen; `browser.set-recipes`: recipes in the panel's place (crafting grids, cooking, stonecutting, smithing and brewing layouts, their slots cycling through their stacks, a note and an action button each), paged by the game, with clicks on their slots, action buttons, page turns and a back button. **Experimental:** the manifest needs `experimental = ["ui"]` |
+| `render` | `render` | `set-hud(shapes)`: up to 1024 fills, four-cornered shapes, GUI sprites, items and text, kept on the HUD (over the hotbar, under chat and screens, hidden with F1) until replaced; `set-corner(corner, w, h, shapes)`: a box the game places in a corner, stacked with its overlays and other panels, as `hud`'s panels are; `text-width(text)`; `frame-stats()`: the game's FPS, min and 1% low; `gui-size()`; `shake(strength, seconds)`: the view turns, the player doesn't, scaled by Distortion Effects; `set-zoom(zoom)`: the field of view divided by up to 10, eased or at once, with slower turning, while playing and not through a spyglass (the strongest of several mods' zooms counts); `set-minimap(minimap)`: a map of the world around the player in a corner, as a map item colours it (the floor underground and under roofs), square or round, turning with the player or north up, with the player's arrow; the game keeps its tiles within its own frame budget (one map at a time, the first loaded mod's); `set-far-terrain(far-terrain)`: the world past the render distance as distant terrain, out to 64 to 1024 chunks, built by the game's own workers (the player's LOD Distance, when on, wins; the first loaded mod's). The game's own HUD renderer draws them: a mod never supplies shader code. **Experimental:** `experimental = ["render"]` |
 | `input` | `input` | `claim-items(ids)`: the use button on those items is the mod's (`use-start`, `use-stop` with the ticks held; the game doesn't place, eat or swing); `register-key(name, label, key)`: up to 16 keys (`key.keyboard.r`), heard while playing as `key-down` / `key-up` (the game's own mapping on that key still runs; a screen opening lets held keys up), mouse buttons as `key.mouse.4`. The player rebinds them on the mod's page in Options > Mods, where the game lists them first as Key Binds rows (click, then press a key or mouse button; Esc binds none), even for a mod without `ui`; the choice is kept in `horizon-mods.txt` (`key.<mod>.<name>:key.keyboard.z`) and wins over `register-key`'s default; `claim-wheel(on)`: the wheel's steps become `wheel` events and the hotbar doesn't move (the one input a mod takes from the game; a mod's keys never do); `held()`; `mapping(name)`: a movement or click mapping's key label and whether it is held; `clicks-per-second()`; `poll()` returns the events, at most 256 kept. **Experimental:** `experimental = ["input"]` |
+| `recipes` | `recipes` | `items()`: every item in the registry's order, with its name in the player's language and its tags; `all()`: every recipe (crafting, smelting, blasting, smoking, campfire, stonecutting, smithing, brewing), its slots as the stacks that fit each, its results, cooking time and experience, and the recipe book's id for it; `known()`: the book ids the player's recipe book holds; `place(book-id, all)`: the recipe book's click on a recipe, in the open inventory's or crafting table's grid (refused for a recipe the player's book doesn't hold, as vanilla's server refuses it); `give(stack)`: in creative mode, the stack into the player's inventory, as from the creative inventory. The recipes are the world's in single player and on Horizon's servers, vanilla 26.3's on any other server (a client is sent no others), while `known` follows that server's book. The game makes the tables once, when a mod first reads them. **Experimental:** `experimental = ["recipes"]` |
 
 | Hook (export) | When |
 |---|---|
@@ -116,7 +117,6 @@ loading. Ordered by what the first native ports need:
 | `keys` | keybinds | registered binds appear in Controls; press/release events |
 | `target` | the crosshair's block or entity, with its state and NBT summary | Jade/WTHIT-style tooltips |
 | `inventory-read` | the player's inventory, held item, open container | AppleSkin, recipe viewers |
-| `recipes` | the recipe registry and lookups | JEI/EMI-style viewers |
 | `world-read` | blocks and biomes around the player, within the render distance | minimaps, schematics |
 | `render` (world) | world-space lines, boxes and billboards, beside the HUD shapes `render` has | Litematica-style placement, waypoints |
 | `registries` | new blocks, items, entities and recipes, mostly data: JSON models, textures, loot and recipes in the `.hmod`'s `assets/` and `data/` | server side; see [Multiplayer](#multiplayer) |
@@ -285,6 +285,7 @@ A step's parts happen in this order:
 | --- | --- |
 | `reload = true` | stops the mod and starts it again, as a rebuild does in the game: its memory starts over, its `storage` stays |
 | `title-screen = true` | no player and no clock until a step sets them |
+| `blocks = [{ x = 0, y = 63, z = 0, state = "minecraft:stone" }]` | server mods with `world`: those blocks of the Overworld, before the rest of the step (every other block is air, every biome the dimension's plainest: plains, nether wastes, the end) |
 | `player = { x = 3.0, ... }`, `clock = { day-time = 0 }` | changes those fields (`x y z yaw pitch health food dimension`, `game-time day-time`) |
 | `ticks = n`, `frames = n` | that many ticks (the game's tick counter and the clock move on), then frames 1/60 s apart |
 | `chat = "<Steve> hi"` | a chat line the player receives |
@@ -310,6 +311,7 @@ checked:
 | `feedback = "..."`, `error = "..."` | the command's answer, shown plain or in red |
 | `panel = ["..."]`, `corner = "top-left"` | its HUD panel's lines (`[]`: no panel) and corner |
 | `told = ["Alex: Welcome!"]`, `broadcast = ["..."]` | server mods: every `players.tell` (as `name: text`) and `players.broadcast`, in order |
+| `blocks = [{ x = 2, y = 64, z = 0, state = "minecraft:glowstone" }]` | server mods with `world`: those blocks of the Overworld after the step, the mod's `set-blocks` made (the script checks a state's shape; the game checks its name) |
 | `stopped = "panic"` | the mod was turned off, for a reason holding this text; without it, a mod that traps, panics or overruns fails the test |
 
 Unknown keys are errors, so a typo never passes silently. The same runner is
@@ -478,6 +480,7 @@ its component targets the WIT world `horizon-server-mod` instead of
 | `log` | always | as for client mods |
 | `storage` | `storage` | as for client mods, in the server's `horizon-mods/` |
 | `players` | `players` | `online()`: id, name, position, dimension, game mode, health of each player on; `tell(id, text)`, `broadcast(text)`: system messages after the mod's name, 8 per call |
+| `world` | `world` | `get-block(dimension, x, y, z)`: the state in a loaded chunk, `minecraft:oak_log[axis=y]`; `get-biome(dimension, x, y, z)`: `minecraft:plains`, ...; `set-blocks(dimension, changes)`: up to 4096 per call, checked at once, made as `/setblock` makes them (neighbours, light, block entities, every player told) after the call, before that dimension's next tick |
 
 | Hook (export `server-events`) | When |
 |---|---|
@@ -485,13 +488,51 @@ its component targets the WIT world `horizon-server-mod` instead of
 | `tick(tick)` | each server tick |
 | `player-joined(player)`, `player-left(player)` | `registration.joins` |
 | `chat(player, text)` | `registration.chat`: each chat message a player sends |
-| `command(player, name, args)` | `/name args` typed by a player, for a command it registered; `ok(some)` is that player's feedback, `err` their red error |
+| `command(player, name, args, values)` | `/name args` typed by a player, for a command it registered, with its arguments' values (below); `ok(some)` is that player's feedback, `err` their red error |
 | `block-broken(player, pos, state)`, `block-placed(player, pos, state)` | `registration.blocks`, with the state as `minecraft:oak_log[axis=y]` |
 
 Capabilities that act on a local player (`game-read`, `chat`, `hud`) are for
 client mods; `players` is for server mods. In Rust: `impl
 horizon_mod_sdk::server::ServerMod` and `export_server_mod!`; the example is
-[`welcome`](../crates/horizon-mod-sdk/examples/welcome/src/lib.rs).
+[`welcome`](../crates/horizon-mod-sdk/examples/welcome/src/lib.rs), and with
+`world`, [`beacons`](../crates/horizon-mod-sdk/examples/beacons/src/lib.rs).
+
+**Typed commands.** Each command in `registration.commands` lists its
+arguments, in order: a name and a kind, required or optional (optional ones
+last). The server adds them to the command tree every player receives, after
+vanilla's commands, so a player's chat box completes and colours them as it
+does vanilla's (player names, coordinates, bounds); when a player sends one,
+the server parses the line the way vanilla's parsers do and gives the mod the
+values, by argument name, or answers with vanilla's error (`Integer must not
+be more than 64, found 65`, `No player was found`) without calling the mod.
+
+| Kind | Takes | Value | Chat box parser |
+|---|---|---|---|
+| `word` | one word: letters, digits, `_ - . +` | `word(string)` | `brigadier:string` (word) |
+| `text` | the rest of the line, only last | `text(string)` | `brigadier:string` (greedy) |
+| `integer(min, max)` | a whole number within the bounds given | `integer(s32)` | `brigadier:integer` |
+| `number` | a number | `number(f64)` | `brigadier:double` |
+| `boolean` | `true` or `false` | `boolean(bool)` | `brigadier:bool` |
+| `player` | an online player's name, `@s` or `@p` (whoever typed it) | `player(player)` | `minecraft:entity` (one player) |
+| `block-pos` | `x y z`, each a whole number, `~` or `~n` (from whoever typed it) | `block-pos(block-pos)` | `minecraft:block_pos` |
+
+A command with no arguments takes nothing after its name. In Rust,
+`Registration::command_with("beacon", [Argument::integer("height", Some(1),
+Some(64)).optional()])`, read with `args.integer("height")`; `command(name)`
+alone takes free text, an optional `text` argument named `args`
+(`args.text()` is the line as typed either way).
+
+**Capability `world`.** Reads are of the server's loaded chunks as they are
+during the call: the game lends a server mod's call the levels' chunk maps
+(moved, not copied, and only while a running mod has `world`), so a read
+costs a map lookup and no copy of the world. A dimension with no chunk loaded
+at a position reads as none. Writes go through the same code as `/setblock`,
+so block updates, light, block entities and every client (LAN guests,
+dedicated server players) see them as vanilla's; the parity harnesses test
+that code. Changes for a dimension whose level isn't ticking wait for it
+(in-frame single player ticks only the player's), up to 65,536 blocks; a
+change in a chunk that isn't loaded when it is made is skipped, as `/setblock`
+refuses one.
 
 **Where they run.** The game that simulates the world starts the server mods
 that are on, and only that one:
@@ -521,10 +562,11 @@ chat for the in-frame player and a system message for a connection;
 on, each of these points costs one branch (measured in the PR that added
 them).
 
-**Not yet.** Clients aren't sent server mods' commands with vanilla's
-command tree, so a player's chat box doesn't complete or colour them; typing
-them works. Block events are a player's own breaking and placing, not
-explosions, pistons or other mods.
+**Not yet.** Block events are a player's own breaking and placing, not
+explosions, pistons or other mods. Command arguments don't take entities,
+items or block states yet, and `^` coordinates; in-frame single player's chat
+box lists server mods' commands by name only (the server still parses their
+arguments).
 
 ## Publish your mod
 
@@ -555,7 +597,7 @@ says how). The formats: [api/mod-index.md](api/mod-index.md).
 
 ### Horizon's official mods
 
-The Horizon extras that are mods now live in `mods/official/<name>/`, one crate each in the game's workspace, so
+The Horizon extras that are mods now, and Horizon's own recipe viewer, live in `mods/official/<name>/`, one crate each in the game's workspace, so
 `cargo clippy --workspace` and pr_ready cover them. They use only the public API, like any other mod, with the same
 options on their settings page as the extra had and the same look. Each is published by a maintainer: build it on
 `main` with the toolchain CI uses (`cd mods/official/<name> && cargo horizon-mod build`), then open a pull request in
@@ -569,6 +611,8 @@ so the same rustc and `Cargo.lock` give the same file.
 | Keystrokes | `keystrokes` | Extras > Keystrokes | `corner`: as above, default `top_left`; `cps`: `true` (default), `false` |
 | Zoom | `zoom` | Extras > Zoom | `level`: `2`, `3`, `4` (default), `6`, `8`, `10`; `smooth`: `true` (default), `false`; `sensitivity` (slower turning): `true` (default), `false`. The key is the game's: `key.zoom.zoom` in `horizon-mods.txt`, default `key.keyboard.z` |
 | Minimap | `minimap` | Extras > Minimap | `corner`: as above, default `top_right`; `size`: `64`, `96` (default), `128`; `shape`: `square` (default), `round`; `zoom` (blocks per pixel): `0.5`, `1` (default), `2`, `4`; `rotate`: `false` (default), `true`. The game draws the map (`render.set-minimap`) |
+| Far View | `far_view` | Graphics > LOD Distance and Far Detail | `distance` (chunks): `64`, `128`, `256` (default), `512`, `1024`; `detail`: `full` (default), `reduced`. The game builds and draws the distant terrain (`render.set-far-terrain`); the player's LOD Distance, when on, wins |
+| Recipes | `recipes` | nothing (new) | `give` (a click on the item panel gives the item in creative mode: one, a stack with a right click): `false` (default), `true`. The keys are the game's: `key.recipes.recipe` (default `key.keyboard.r`) and `key.recipes.uses` (default `key.keyboard.u`) in `horizon-mods.txt`. Every item sits in the item panel (`browser`) with a search box (words in the name or id, `@namespace`, `#tag`); R or a click shows an item's recipes, U or a right click its uses, a tab per station, and + fills the grid with a recipe the player knows (`recipes.place`). On servers that are not Horizon it shows the game's own 26.3 recipes; known recipes and + follow the server's recipe book |
 
 ## Versions and compatibility
 
diff --git a/docs/parity-workflow.md b/docs/parity-workflow.md
index 27505d9de..5c83c6a33 100644
--- a/docs/parity-workflow.md
+++ b/docs/parity-workflow.md
@@ -40,10 +40,23 @@ The game logs into `HORIZON_HOME` and falls back to the player's own game folder
 
 ### Other machines
 
-Harnesses can also run on the Mac mini, the desktop and playhorizon (`tools/parity_hosts.json` describes them; `desktop` and `playhorizon` use their CI runner's environment and vanilla data, and the desktop refuses work, or stops it, while someone uses it: docs/release-flow.md, "The desktop's runner"; its `default` list is empty, so pass `--hosts macmini,playhorizon` or set `PARITY_HOSTS`, after copying `shared-local/` to `~/code/horizon-parity/shared-local` on each host). The runner mirrors the worktree there with rsync (not `.git`, `.local`, `target` or ignored files) into `~/code/horizon-parity/remote/<host><path>`, whose `.local` links to the vanilla data in `~/code/horizon-parity/shared-local`, and starts `tools/parity.py --worker` over ssh. The worker builds the probes (about 80 s the first time) and runs what it is sent under the same tracer, admitting harnesses against its own free memory. One queue, longest first, feeds every machine, remote ones first: the Mac takes up to 14 harnesses, the desktop 8, playhorizon 6. Each pass comes back with the content hash of every file it depended on, so it is keyed on exactly what ran, and logs come back to `.local/parity-runner/logs/`; state, sharing and `gate.py` work as before. If a host can't be reached, or drops out, its harnesses run here.
+Harnesses can also run on the Mac mini, the desktop and playhorizon (`tools/parity_hosts.json` describes them; `desktop` and `playhorizon` use their CI runner's environment and vanilla data, and the desktop refuses work, or stops it, while someone uses it: docs/release-flow.md, "The desktop's runner"; its `default` list is empty, so pass `--hosts macmini,playhorizon` or set `PARITY_HOSTS`, after copying `shared-local/` to `~/code/horizon-parity/shared-local` on each host). The runner mirrors the worktree there with rsync (not `.git`, `.local`, `target` or ignored files) into `~/code/horizon-parity/remote/<host><path>`, whose `.local` links to the vanilla data in `~/code/horizon-parity/shared-local`, and starts `tools/parity.py --worker` over ssh. The worker builds the probes (about 80 s the first time) and runs what it is sent under the same tracer, admitting harnesses against its own free memory. One queue, longest first, feeds every machine, remote ones first: the Mac takes up to 14 harnesses, the desktop 8, playhorizon 3 (on CPUs 0-3: its CI runner has 4-7). Each pass comes back with the content hash of every file it depended on, so it is keyed on exactly what ran, and logs come back to `.local/parity-runner/logs/`; state, sharing and `gate.py` work as before. If a host can't be reached, or drops out, its harnesses run here.
 
 Harnesses a host can't run are listed in the file: `local_only` (`save_roundtrip` runs the game on a virtual screen) and each host's `exclude`. The Mac excludes nothing: vanilla's `Math.sin`, `pow`, `log` and the like don't round the same on an Apple silicon Mac as on Linux (HotSpot uses fdlibm there, Intel's stubs on x86-64), and Rust's float functions round like neither (they call the platform libm), so code that mirrors a vanilla `Math` call uses `horizon_core::jmath`, which computes what HotSpot computes on the host architecture. The ThinkPad no longer runs harnesses (2026-10-26): playhorizon is the Linux host that is always on.
 
+The file's `solo` list names harnesses that drive game windows (`remote_fireworks`, `server_player_sculk`, `world_reopen`, ...). On a machine where `parity.py` has 4 CPUs or fewer, such as playhorizon's CI runner, each of them runs alone, after the others: there frames are drawn on the CPU, and beside other harnesses a screenshot or a control request took more ticks than the check allows. `PARITY_SOLO=1` or `0` forces this on or off.
+
+### Any command on playhorizon: `tools/remote.sh`
+
+For Linux work that doesn't need a whole parity run (a crate's tests, a few harnesses, a server build), `tools/remote.sh <worktree> <command...>` runs the command on playhorizon at the worktree's commit and streams its output back; its exit status is the command's. Commit and push first: the host fetches the commit from GitHub, and nothing else leaves this machine (no files, no credentials, no environment). Each worktree keeps one checkout there, `~/remote-work/<name>` with its own `target/`, so the next run only rebuilds what changed, and one run per name goes at a time. The command runs niced in the host's CI slice, pinned to CPUs 0-3 (`--cpus`): the CI runner has 4-7, so these runs never slow a pull request's parity job. A benchmark asks for its CPUs with `--cpus 0-3 --exclusive` (and says so in its pull request): it starts only when no other run uses them, and later runs wait for it to end. The command gets scratch game and launcher homes and the vanilla data linked as CI links it; a command naming `parity`, `lan_e2e` or `horizon-prepare` also gets `.local/horizon-client`, prepared as CI prepares it. Whatever the command leaves running (a game, a daemon) is stopped when it ends, and stopping `remote.sh` (or losing the connection) stops the command on the host. Logs stay in `~/remote-work/<name>.logs/`; `--list` shows the checkouts, `--gc [DAYS]` removes old ones.
+
+```sh
+tools/remote.sh .claude/worktrees/my-fix cargo test -p horizon-world --lib   # 33 s, warm
+tools/remote.sh . python3 tools/parity.py food                               # 19 s warm (4 min the first time); here: 188 s, 229 CPU-seconds
+```
+
+The host is lent by a partner who keeps hypervisor access: send it no secret, token or credential, and never take a result from it as a CI result.
+
 ### Shards and Rust scopes
 
 A harness can declare, at the top level of its script:
@@ -53,7 +66,7 @@ A harness can declare, at the top level of its script:
 
 ### Which harnesses a change affects
 
-`--changed` and `--changed-files` narrow each harness's Rust sources to those its probes can reach (`tools/parity_reach.py`), so a change to one module of `horizon-client` no longer reruns every harness whose probe links the crate. The narrowing works on items, not files: from the probe modules a harness ran (or the binary it built), a free item (fn, type, const, static) is reached when a reached item names it in its own module, through a path or an import of a module that is named, or through a glob import; an inherent impl's methods count one by one once their type is reached and their name is mentioned; a trait impl counts once its trait and its type are reached (std's traits and types always are); a macro counts once invoked. Names match by spelling, so the result only over-approximates. A reached file's parent modules count through their `mod` declarations of it, compared with the merge base; Rust files a change adds take part, a dependency that was deleted counts as changed, code under `#[cfg(test)]` never counts, and a harness whose probe can't be found keeps every source. Parses are cached by content in `reach-cache.json` of the shared parity folder (beside `passes/`), so a new worktree starts warm; a harness's search stops as soon as it reaches a changed file, and after `PARITY_REACH_BUDGET` seconds (default 180) the remaining harnesses count every source their probes link, so choosing never holds a slow machine for long. `--by-crate` turns the narrowing off. On the last 20 pull requests merged on 2026-10-25, the harnesses picked went from 2255 to 1061 (2384 to 1592 harness-minutes; game-binary harnesses, which link all of `game/`, set the floor), and every harness a CI parity run failed in the week before was still picked; every source file a sample of probes executed (LLVM `-C instrument-coverage`) is among those kept. Building the graph takes 15 s cold, under a second warm, and up to a minute and a half on a change that reaches many harnesses.
+`--changed` and `--changed-files` narrow each harness's Rust sources to those its probes can reach (`tools/parity_reach.py`), so a change to one module of `horizon-client` no longer reruns every harness whose probe links the crate. The narrowing works on items, not files: from the probe modules a harness ran (or the binary it built), a free item (fn, type, const, static) is reached when a reached item names it in its own module, through a path or an import of a module that is named, or through a glob import; an inherent impl's methods count one by one once their type is reached and their name is mentioned; a trait impl counts once its trait and its type are reached (std's traits and types always are); a macro counts once invoked. Names match by spelling, so the result only over-approximates. A reached file's parent modules count through their `mod` declarations of it, compared with the merge base; Rust files a change adds take part, a dependency that was deleted counts as changed, code under `#[cfg(test)]` never counts, and a harness whose probe can't be found keeps every source. Parses are cached by content in `reach-cache.json` of the shared parity folder (beside `passes/`), so a new worktree starts warm; a harness's search stops as soon as it reaches a changed file, and after `PARITY_REACH_BUDGET` seconds (default 180) the remaining harnesses count every source their probes link, so choosing never holds a slow machine for long. `--by-crate` turns the narrowing off. With `--changed`, `Cargo.lock` and `Cargo.toml` changes that only add, remove or move workspace crates (a crate split: no registry or git package, version, feature, dependency or build setting changed across them, compared with the merge base) don't count: the moved code counts through its sources. A workspace crate's feature that such a change defines or turns on is allowed only where every source naming it changed too (the new crate's own files). #2160's split went from 352 harnesses to 123 this way (its own changes to the runner still select them all). On the last 20 pull requests merged on 2026-10-25, the harnesses picked went from 2255 to 1061 (2384 to 1592 harness-minutes; game-binary harnesses, which link all of `game/`, set the floor), and every harness a CI parity run failed in the week before was still picked; every source file a sample of probes executed (LLVM `-C instrument-coverage`) is among those kept. Building the graph takes 15 s cold, under a second warm, and up to a minute and a half on a change that reaches many harnesses.
 
 ## The gate
 
@@ -133,6 +146,13 @@ when named and in the nightly audit (`--all`). LAN writes `results.json`
 with the host mode and each result beside its screenshots and logs. A skipped
 case is recorded explicitly and does not count as passing coverage.
 
+`known_flaky` in `tools/parity_hosts.json` lists harnesses that fail now and then for a
+cause not fixed yet, each with its reason. One that fails runs once more from
+scratch, and a pass then counts. `parity.py` prints a `RETRIED` line for it
+in its summary and in the CI job's summary (PR parity and parity-main), so the
+flake stays visible. No other harness gets this retry. Fix the cause, then take
+the harness off the list.
+
 The game-binary fixture audit keeps these complementary direct rule tests:
 
 - `command_harness.rs`: command feedback, styled spans and result callbacks,
diff --git a/docs/release-flow.md b/docs/release-flow.md
index ce7934824..be0ccbee8 100644
--- a/docs/release-flow.md
+++ b/docs/release-flow.md
@@ -13,7 +13,7 @@ reopened; labels never start it):
 | Job | Runs on | What | Time |
 | --- | --- | --- | --- |
 | `verify` | GitHub `ubuntu-latest` | Public-tree check, Python tests, rustfmt, clippy with warnings denied, Rust tests. Dependencies and the workspace build come from a cache saved by main's runs | ~4 min cold, less warm |
-| `parity / parity` | A runner with the label `horizon-game`: the Mac mini's two, and the desktop's while nobody uses it (below) | Only for a change to a harness, an oracle, a probe or the runner (or the `run-parity` label): the vanilla harnesses the change can affect (`tools/parity.py --changed <base>`). Other pull requests skip it: [parity-main](#parity-on-main) checks them on main | seconds when nothing is affected; minutes per affected harness |
+| `parity / parity` | A runner with the label `horizon-game`: the Mac mini's and playhorizon's (below) | Only for a change to a harness, an oracle, a probe or the runner (or the `run-parity` label): the vanilla harnesses the change can affect (`tools/parity.py --changed <base>`). Other pull requests skip it: [parity-main](#parity-on-main) checks them on main | seconds when nothing is affected; minutes per affected harness |
 
 Pushes to main run `verify` only; the nightly audit covers main's harnesses.
 
@@ -27,11 +27,23 @@ quick steps and finishes in seconds.
 The job is `.github/workflows/parity.yml`, a reusable workflow: `checks` calls it for pull requests from this
 repository, `run-parity.yml` for a fork's pull request a maintainer labels `run-parity`.
 
+A pull request every harness reaches (a crate split moves files every probe links: #2160 ran all 352 harnesses, 71
+minutes on a Mac mini runner, while five other pull requests' jobs queued behind it) carries the `full-parity` label:
+its job runs on playhorizon's runner only (4 harnesses at a time), and waits for it while that runner is busy
+instead of taking the Mac mini's. Labels don't start `checks`: add it when opening the pull request
+(`gh pr create --label full-parity`), or before the next push.
+
 Horizon never downloads the game, so harnesses that compare with vanilla run only where the maintainer's own
-copy is: the Mac mini, his Linux desktop and playhorizon (below). Their runners run as the maintainer's account and keep their checkout
+copy is: the Mac mini and playhorizon (below). Their runners run as the maintainer's account and keep their checkout
 between runs (`clean: false`), so the probes build incrementally into `.local/parity-target` and earlier passes
 stand.
 
+The job tests the pull request's head merged into main's current tip, which is what merging it would land: harness
+and game fixes that reached main after the branch was made apply to it too, and an old branch runs main's runner
+scripts and selection unless it changes them. The base for the selection is that main commit, so only the pull
+request's own changes count. The job summary names the main commit. A head that conflicts with main is tested
+alone, with a warning. The check is still reported on the head.
+
 1. `tools/ci/runner-env.sh` puts the machine's Python 3.13 and the JDK `research-lock.json` pins on the PATH
    (Homebrew and `java_home` on the Mac; on Linux what `linux-runner.sh` pinned, else nixpkgs), and sccache when
    the machine has it.
@@ -50,9 +62,6 @@ stand.
    modules, Java oracles and every Rust source their probes compile) changed since the merge base, plus any
    harness nothing is recorded about yet, and runs those that have no pass for their current inputs. A change to
    `Cargo.lock` or `research-lock.json` affects every harness. Each harness has 25 minutes, the job 45.
-   The selection runs with main's `tools/parity.py` and `tools/parity_reach.py` (`--changed <base> --list`), so a
-   branch made before a better selection landed gets it too, and the head's own `parity.py` then runs the named
-   harnesses. A branch that changes either file selects with its own code.
 
 Failed harnesses' logs are uploaded as the `parity-logs` artifact.
 
@@ -74,8 +83,9 @@ release's macOS build back. Each keeps its own checkout, `target/` and Rust inst
 `_work/horizon/shared-local` links to the first's, so they share the vanilla data, the preparations (one at a
 time, under a lock) and the parity passes and slots.
 
-**The desktop's runner.** `ludodesktop-horizon` (labels `self-hosted`, `Linux`, `X64`, `ludodesktop`, and
-`horizon-game` once a full trial has passed there) runs on the maintainer's Linux desktop while nobody uses it: its
+**The desktop's runner (retired).** On 2026-10-26 the maintainer asked that CI stop using his desktop: its services are
+stopped and `ludodesktop-horizon` has no label a job asks for (only `self-hosted`, `Linux`, `X64`), so nothing waits for
+it. What follows describes it as it ran. It ran on the maintainer's Linux desktop while nobody used it: its
 screen locked, or untouched for 15 minutes (his rule, 2026-10-26). `tools/ci/linux-runner.sh install`, run there as
 him, registers it and installs two systemd user services: `horizon-runner` (the runner, in
 `~/.actions-runners/horizon`, nice 19, in `horizon-ci.slice` with CPU and I/O weight 20, half the threads (on all of
@@ -96,12 +106,16 @@ and its failures bisect and comment on merges.
 
 **playhorizon's runner.** `playhorizon-horizon` runs on a server a hosting partner lends the project (Ubuntu, 8
 AMD EPYC threads, 30 GB, in Detroit; reachable only through the maintainer's tailnet). Nobody sits at it, so the
-watcher never pauses it except by hand, and it gets the machine: `RUNNER_CPUS=7 RUNNER_MEMORY=24 RUNNER_JOBS=6`.
+watcher never pauses it except by hand. It gets half the machine: `RUNNER_MEMORY=24`, `CARGO_BUILD_JOBS` and the
+harness slots at 4, and a drop-in (`~/.config/systemd/user/horizon-runner.service.d/cpus.conf`) that starts it under
+`taskset -c 4-7` (the user slice can't set `AllowedCPUs`: systemd doesn't delegate the cpuset controller to it).
+Agents' `tools/remote.sh` runs and benchmarks share CPUs 0-3, so they never slow a pull request's job.
 Without Nix, `linux-runner.sh` takes the build libraries, the JDK, sccache, Xvfb and Mesa's software Vulkan
 (lavapipe; there is no GPU) from apt, and Python 3.13 from uv. The partner can reach the machine, so gh is not
 logged in there: the registration token comes from another machine (`RUNNER_TOKEN`), and no job with secrets may
-run there (parity has none). It is also a parity host (`playhorizon` in `tools/parity_hosts.json`, 6 jobs). Like
-the desktop's, it gets the `horizon-game` label only once a full trial has passed there.
+run there (parity has none). It is also a parity host (`playhorizon` in `tools/parity_hosts.json`, 3 jobs on CPUs 0-3). Since
+2026-10-26 it has the `horizon-game` label: pull requests' parity jobs run there or on the Mac mini, and `full-parity`
+ones only there.
 
 ## Merging
 
@@ -209,6 +223,7 @@ How releases are numbered, and how installs from before 0.2 reach it: [versionin
 | `release-now` | Releases as soon as main's checks pass, without waiting for merges to settle |
 | `skip-release` | Doesn't trigger a release and isn't listed in the notes |
 | `run-parity` | Runs the parity job once on a fork's pull request |
+| `full-parity` | Runs the pull request's parity job on playhorizon's runner only (a change every harness reaches) |
 | `parity-regression` | Opened by the nightly audit for a harness that fails on main |
 | `release-blocker` | On an issue: no game release is published while it is open ([One channel](#one-channel)) |
 
@@ -417,6 +432,9 @@ Releases ship often, so nothing they leave behind may grow without bound.
   (`~/.actions-runners/runner-gc.sh`, plist `dev.horizon.runner-gc`), never from a pull request's checkout. It skips a
   runner in a job, removes a checkout's cargo build folders past 12 GB (`MAX_TARGET_GB`) and harness work folders
   under `.local/` untouched for 3 days (`STALE_DAYS`), and keeps the 2 newest shared preparations (`KEEP_PREPARED`)
-  while no runner works. Runner builds go through the machine's sccache (`tools/ci/runner-env.sh`), so what it removes
+  while no runner works. It also stops harness JVMs (vanilla servers, oracles) left orphaned for 3 hours
+  (`ORPHAN_HOURS`): parent gone, command line under a runner's checkout or a worktree's `.local/`. `tools/parity.py`
+  stops its own harnesses on SIGTERM and SIGHUP (a cancelled job), so these come only from a SIGKILL or a harness run
+  by hand. Runner builds go through the machine's sccache (`tools/ci/runner-env.sh`), so what it removes
   comes back from the cache. Update the copy after changing the script:
   `ssh macmini 'curl -fsSL https://raw.githubusercontent.com/ludovic111/horizon/main/tools/ci/runner-gc.sh -o ~/.actions-runners/runner-gc.sh'`.
diff --git a/docs/resource-packs.md b/docs/resource-packs.md
index 783c381dd..f29569068 100644
--- a/docs/resource-packs.md
+++ b/docs/resource-packs.md
@@ -31,9 +31,9 @@ harness named checks that loader against vanilla).
 | --- | --- | --- | --- |
 | Pack metadata: description, icon, `min_format`/`max_format`, old `supported_formats`, compatibility warning | `pack.mcmeta`, `pack.png` | works | `test_pack_screen_parity`, `test_pack_selection_parity` |
 | Overlays per format | `pack.mcmeta` `overlays` | works | `test_resource_pack_parity` (an overlay for 26.3 applied, an older one not) |
-| Filters | `pack.mcmeta` `filter` | works | `test_resource_pack_parity` (`packs/pattern.rs` regex subset) |
+| Filters | `pack.mcmeta` `filter` | works | `test_resource_pack_parity` (`horizon-client-core/src/pattern.rs` regex subset) |
 | Folder and zip packs, order, built-in packs | `resourcepacks/` | works | `test_resource_pack_parity`, `test_pack_selection_parity` |
-| Server resource packs: the prompt, the server list's Server Resource Packs setting, download (250 MiB, SHA-1, `downloads/` keeps 20), applied on top of the player's packs, removed on leaving | the server's `resource_pack_push`/`_pop` | works, no download toasts | `tools/server_pack_e2e.py` (against vanilla's server and Horizon's), unit tests in `server_packs.rs`; `test_server_resource_pack_parity` for Horizon's server |
+| Server resource packs: the prompt, the server list's Server Resource Packs setting, download (250 MiB, SHA-1, `downloads/` keeps 20), download toasts, a progress screen while the packs reload, applied on top of the player's packs, removed on leaving | the server's `resource_pack_push`/`_pop` | works | `tools/server_pack_e2e.py` (against vanilla's server and Horizon's), unit tests in `server_packs.rs`; `test_server_resource_pack_parity` for Horizon's server |
 | Other namespaces | `assets/<namespace>/` | works | `test_resource_pack_parity` |
 | Block states: variants, multipart, weights, rotations, uvlock | `blockstates/` | works | `test_blockstate_model_parity`, `test_model_choice_parity`, `test_blockstate_transform_parity` |
 | Block models: parents, elements, rotations, faces, cullface, tint, shade, light emission, ambient occlusion | `models/block/` | works | `test_model_resolution_parity`, `test_model_baking_parity`, `test_section_mesh_parity` |
@@ -84,7 +84,6 @@ shaders, the missing pieces are missing vanilla features too, and each vanilla p
 | Gap | Size | Where |
 | --- | --- | --- |
 | Animation `interpolate` | small | fix PR (`gfx.rs` `animate_sprites`) |
-| Server pack download toasts (`download.pack.*`) | small | `game/server_packs.rs` |
 | GUI scaling `width`/`height`, `stretch_inner`, `tile`, `stretch` | small | next fix PR (`ui.rs`) |
 | Villager hats | small | [#334](https://github.com/ludovic111/horizon/issues/334) |
 | `blur`/`clamp` from packs | small | [#335](https://github.com/ludovic111/horizon/issues/335) |
diff --git a/docs/version-ports.md b/docs/version-ports.md
index 623e3c082..4ecad210f 100644
--- a/docs/version-ports.md
+++ b/docs/version-ports.md
@@ -43,7 +43,7 @@ to players. Players still prepare their own copy from their official launcher (`
   | `crates/horizon-client/src/lan/tracking.rs` | `generate_entity_tracking.py` | decompiled `EntityTypes` |
   | `crates/horizon-client/src/lan/command_suggestions.rs` | `generate_command_suggestions.py` | `VanillaCommandSuggestionsExporter` |
   | `crates/horizon-client/src/lan/command_order.rs` | `generate_lan_command_order.py` | vanilla's command tree |
-  | `crates/horizon-client/src/command/vanilla_order.rs` | `generate_command_order.py` | command-parse harness export |
+  | `crates/horizon-command/src/vanilla_order.rs` | `generate_command_order.py` | command-parse harness export |
   | `crates/horizon-world/src/datafix/block_state_data.txt` | `gen_block_state_data.py` | decompiled `BlockStateData` |
   | `crates/horizon-world/src/datafix/flat_tables.rs` | `gen_flat_tables.py` | 1.13 flattening fixers (never change) |
 
diff --git a/launcher/Cargo.lock b/launcher/Cargo.lock
index dd9313df6..c0fa55f15 100644
--- a/launcher/Cargo.lock
+++ b/launcher/Cargo.lock
@@ -70,6 +70,15 @@ dependencies = [
  "equator",
 ]
 
+[[package]]
+name = "android_system_properties"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "anstream"
 version = "1.0.0"
@@ -919,6 +928,17 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "chrono"
+version = "0.4.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
+dependencies = [
+ "iana-time-zone",
+ "num-traits",
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "cipher"
 version = "0.4.4"
@@ -981,6 +1001,15 @@ version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486"
 
+[[package]]
+name = "cobs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
+dependencies = [
+ "thiserror 2.0.21",
+]
+
 [[package]]
 name = "cocoa"
 version = "0.25.0"
@@ -1635,6 +1664,18 @@ dependencies = [
  "winreg",
 ]
 
+[[package]]
+name = "embedded-io"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
+
+[[package]]
+name = "embedded-io"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
+
 [[package]]
 name = "encoding_rs"
 version = "0.8.42"
@@ -2354,7 +2395,7 @@ dependencies = [
  "wayland-protocols-plasma",
  "windows 0.61.3",
  "windows-core 0.61.2",
- "windows-numerics",
+ "windows-numerics 0.2.0",
  "windows-registry 0.5.3",
  "x11-clipboard",
  "x11rb",
@@ -2693,6 +2734,8 @@ dependencies = [
 name = "horizon-launcher"
 version = "0.2.0"
 dependencies = [
+ "base64",
+ "chrono",
  "clap",
  "dirs 5.0.1",
  "flate2",
@@ -2708,6 +2751,7 @@ dependencies = [
  "horizon-release-sign",
  "horizon-telemetry",
  "horizon-theme",
+ "horizon-world",
  "image",
  "keyring",
  "objc2-app-kit",
@@ -2719,7 +2763,10 @@ dependencies = [
  "serde_json",
  "sha1",
  "sha2 0.10.9",
+ "sys-locale",
  "tar",
+ "toml 1.1.8+spec-1.1.0",
+ "trash",
  "ureq",
  "winresource",
  "zip",
@@ -2801,6 +2848,21 @@ dependencies = [
 name = "horizon-theme"
 version = "0.1.0"
 
+[[package]]
+name = "horizon-world"
+version = "0.1.0"
+dependencies = [
+ "flate2",
+ "horizon-core",
+ "libm",
+ "lz4_flex",
+ "postcard",
+ "serde",
+ "serde_json",
+ "sha2 0.10.9",
+ "xxhash-rust",
+]
+
 [[package]]
 name = "http"
 version = "1.5.0"
@@ -2907,6 +2969,30 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "icu_collections"
 version = "2.3.0"
@@ -3425,6 +3511,12 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "lz4_flex"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecbdfe44b1bd960b68170b417450a628c43f7cf56bb3c5317e61cb230ee7f226"
+
 [[package]]
 name = "mac"
 version = "0.1.1"
@@ -4263,6 +4355,18 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "postcard"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
+dependencies = [
+ "cobs",
+ "embedded-io 0.4.0",
+ "embedded-io 0.6.1",
+ "serde",
+]
+
 [[package]]
 name = "potential_utf"
 version = "0.1.6"
@@ -6187,6 +6291,24 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "trash"
+version = "5.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be89b3fe156965d29ac4f8522f3a640c655affdd9f21cb4f36857f0c92c00317"
+dependencies = [
+ "chrono",
+ "libc",
+ "log",
+ "objc2",
+ "objc2-foundation",
+ "once_cell",
+ "percent-encoding",
+ "scopeguard",
+ "urlencoding",
+ "windows 0.62.2",
+]
+
 [[package]]
 name = "try-lock"
 version = "0.2.5"
@@ -6367,6 +6489,12 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
 [[package]]
 name = "usvg"
 version = "0.45.1"
@@ -6820,11 +6948,23 @@ version = "0.61.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
 dependencies = [
- "windows-collections",
+ "windows-collections 0.2.0",
  "windows-core 0.61.2",
- "windows-future",
+ "windows-future 0.2.1",
  "windows-link 0.1.3",
- "windows-numerics",
+ "windows-numerics 0.2.0",
+]
+
+[[package]]
+name = "windows"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580"
+dependencies = [
+ "windows-collections 0.3.2",
+ "windows-core 0.62.2",
+ "windows-future 0.3.2",
+ "windows-numerics 0.3.1",
 ]
 
 [[package]]
@@ -6837,7 +6977,7 @@ dependencies = [
  "rayon",
  "thiserror 2.0.21",
  "windows 0.61.3",
- "windows-future",
+ "windows-future 0.2.1",
 ]
 
 [[package]]
@@ -6849,6 +6989,15 @@ dependencies = [
  "windows-core 0.61.2",
 ]
 
+[[package]]
+name = "windows-collections"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610"
+dependencies = [
+ "windows-core 0.62.2",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.57.0"
@@ -6874,6 +7023,19 @@ dependencies = [
  "windows-strings 0.4.2",
 ]
 
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
+]
+
 [[package]]
 name = "windows-future"
 version = "0.2.1"
@@ -6882,7 +7044,18 @@ checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
 dependencies = [
  "windows-core 0.61.2",
  "windows-link 0.1.3",
- "windows-threading",
+ "windows-threading 0.1.0",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"
+dependencies = [
+ "windows-core 0.62.2",
+ "windows-link 0.2.1",
+ "windows-threading 0.2.1",
 ]
 
 [[package]]
@@ -6951,6 +7124,16 @@ dependencies = [
  "windows-link 0.1.3",
 ]
 
+[[package]]
+name = "windows-numerics"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"
+dependencies = [
+ "windows-core 0.62.2",
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "windows-registry"
 version = "0.4.0"
@@ -6991,6 +7174,15 @@ dependencies = [
  "windows-link 0.1.3",
 ]
 
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "windows-strings"
 version = "0.3.1"
@@ -7009,6 +7201,15 @@ dependencies = [
  "windows-link 0.1.3",
 ]
 
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
@@ -7111,6 +7312,15 @@ dependencies = [
  "windows-link 0.1.3",
 ]
 
+[[package]]
+name = "windows-threading"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.48.5"
@@ -7423,6 +7633,12 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec7a2a501ed189703dba8b08142f057e887dfc4b2cc4db2d343ac6376ba3e0b9"
 
+[[package]]
+name = "xxhash-rust"
+version = "0.8.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "550a2b930b62486a393c52d5c3b84bff264b28aa437ed64694d31e93b1757af7"
+
 [[package]]
 name = "y4m"
 version = "0.8.0"
diff --git a/launcher/Cargo.toml b/launcher/Cargo.toml
index a97f128b8..9e65a2281 100644
--- a/launcher/Cargo.toml
+++ b/launcher/Cargo.toml
@@ -19,8 +19,11 @@ sha2 = "0.10"
 pulldown-cmark = { version = "0.12", default-features = false }
 flate2 = "1"
 tar = { version = "0.4", default-features = false }
+toml = "1.1"
 zip = { version = "2", default-features = false, features = ["deflate"] }
 dirs = "5"
+# The system's preferred languages, for the window's language (i18n.rs).
+sys-locale = "0.3"
 self-replace = "1"
 clap = { version = "4", features = ["derive"] }
 horizon-theme = { path = "../crates/horizon-theme" }
@@ -37,6 +40,13 @@ horizon-mods = { path = "../crates/horizon-mods", features = ["index"] }
 horizon-release-sign = { path = "../crates/horizon-release-sign" }
 # Opt-in data collection: the consent, the outbox and its upload (docs/telemetry.md).
 horizon-telemetry = { path = "../crates/horizon-telemetry" }
+# level.dat and servers.dat (the worlds and server lists of instances)
+horizon-world = { path = "../crates/horizon-world" }
+# Deleting a world moves it to the system's trash
+trash = "5"
+# Backup names carry the local time, as vanilla's do
+base64 = "0.22"
+chrono = { version = "0.4", default-features = false, features = ["clock"] }
 # The session file's random name.
 getrandom = "0.3"
 # Players' heads on the Servers page, from the default skins in the player's own game files (already
diff --git a/launcher/README.md b/launcher/README.md
index 9c6f3a9d9..6aec8b633 100644
--- a/launcher/README.md
+++ b/launcher/README.md
@@ -28,8 +28,8 @@ The opening, then Play ([clip](docs/opening.webm)):
   packs and modpacks, each marked Works, Partly or Doesn't run in
   Horizon; Java mod jars are never offered. Install puts a pack and what it needs in
   `resourcepacks/` only after its SHA-512 matches, and a
-  modpack goes to the Modpacks page; installed packs show their source and checksum, with Update
-  and Remove ([docs/mod-browser.md](../docs/mod-browser.md)).
+  modpack goes to the Modpacks page; installed packs show their source and checksum, with Update,
+  **Update all** and Remove ([docs/mod-browser.md](../docs/mod-browser.md)).
 - **Modpacks**: import a Java modpack (a Modrinth `.mrpack`, a CurseForge zip, or a Prism,
   MultiMC or CurseForge instance folder) and see its coverage report: per mod, ported, partial,
   not yet or not needed, with the reason ([docs/modpacks.md](../docs/modpacks.md)). **Port**
@@ -69,6 +69,123 @@ The opening, then Play ([clip](docs/opening.webm)):
   access controls, one click changes them so friends you share with reach only the server's
   port (Remove the limit undoes it); custom access controls are never rewritten, the page gives
   the rule to add instead. Horizon never turns on Funnel.
+- **Instances**: separate game folders, each with its own worlds, options and packs. The game's
+  folder stays the first one, "Horizon", exactly where it was; imported and registry modpacks are
+  instances too, in their own folders as before; new ones go to `instances/<name>/` in the game's
+  folder, empty but for the player's options and name, or a copy of another instance (never its
+  sign-in sessions, logs or data collection state). Names, icons (a block or item texture from the
+  player's prepared files, or a colour) and groups are kept in `instances.json` in the launcher's
+  data folder, so renaming moves nothing. Every instance follows the launcher's data collection
+  answer and No AI. In the window, **+** beside Instances makes one, the sidebar lists them by
+  group (click one to play it), and Home's Instance row has Edit (name, group, icon), Copy and
+  Open folder. The Instance row shows its play time and when it was last played: every run started
+  from the window or `horizon-launcher play` adds to it (`instance list` shows it too). Each
+  instance plays the launcher's version, which follows updates, unless the Play page's version
+  picker keeps it on another installed one (to keep an old world on the version it was made
+  with); picking the version marked "follows updates" lets it follow again.
+- **Export**: Home's Instance row has **Export…**: the selected instance (or a port) as a `.mrpack`
+  (Modrinth's modpack format: resource packs the browser installed from Modrinth are listed by
+  their download, the rest is in `overrides/`) or a `.zip` of the game folder's layout, with the
+  worlds switched on. It is written to `exports/` in the launcher's data folder (**Show in
+  folder**). Only settings (options.txt, horizon-*.txt, servers.dat), resource and shader packs,
+  `horizon-mods/` and `config/` go in: never logs, screenshots, backups, caches or account files;
+  a world goes without `playerdata/`, `stats/` and `advancements/`, and its level.dat without the
+  player's UUID. `horizon-launcher instance export [<instance>] [--format mrpack|zip] [--world
+  <w>]… [--out <file>]`.
+- **Import by dropping a file**: a file dropped anywhere on the window is imported for what it is
+  (`horizon_launcher::import`). A shared instance (a `.mrpack` that needs no mod loader, such as
+  Export writes, or a game folder `.zip`) becomes a new instance, opened on Home. Its `.mrpack`
+  downloads come from Modrinth with their SHA-512 checked, and only what an instance keeps is
+  taken, inside its folder. A Java modpack goes to the Modpacks import, and a resource or shader
+  pack into the selected instance. A data pack is pointed at the world rows, and the Packs section
+  and the world rows keep taking their own drops. A note in the corner says what happened.
+  `horizon-launcher instance import <file>`.
+- **Launch options**: Home's Instance row has **Launch…**: per instance, a shell command run in its
+  folder before the game (the game starts only if it succeeds), a wrapper the game runs through
+  (`nice -n 5`), and environment variables (`NAME=value OTHER="two words"`), kept in
+  `instances.json` (`horizon_launcher::launch`). The game stays one process the launcher follows:
+  on Unix `/bin/sh` runs the command and then `exec`s the wrapper and the game, whose words pass
+  through `"$@"` untouched; on Windows `cmd /C` runs `<command> && <game>`. Both the window's Play
+  and `play` use them. `horizon-launcher instance launch <instance> [--pre-launch …]
+  [--wrapper …] [--env …]` (an MCP agent needs `confirm: true`: it sets commands Play runs).
+  On Linux the panel also has switches for what the computer has: **GameMode** (`gamemoderun`
+  on the PATH), **MangoHud** (`mangohud`), and, with two graphics cards under
+  `/sys/class/drm`, the **dedicated graphics card** (`DRI_PRIME=1`, or NVIDIA's
+  `__NV_PRIME_RENDER_OFFLOAD`, `__VK_LAYER_NV_optimus` and `__GLX_VENDOR_LIBRARY_NAME` when its
+  driver is loaded). A switch whose tool is gone does nothing. `instance launch --gamemode
+  on|off --mangohud on|off --dedicated-gpu on|off`; `HORIZON_LAUNCHER_LINUX_TOOLS` makes any
+  system show them, for tests.
+- **Desktop shortcut**: Home's Instance row has **Shortcut**: a shortcut on the desktop that plays
+  the selected instance without opening the launcher (`horizon-launcher play --instance <id>`).
+  A `.desktop` file on Linux (also put in the applications menu, and marked trusted with `gio`
+  where it exists), a small app with Horizon's icon on macOS, a `.lnk` on Windows
+  (`horizon_launcher::shortcut`). **Remove shortcut** moves it to the trash; it is found by the
+  instance id inside it, so a rename doesn't lose it. `horizon-launcher instance shortcut
+  [instance] [--remove]`; `HORIZON_LAUNCHER_DESKTOP` points it at another folder.
+- **Accounts and quick switch**: the top bar's account chip opens a menu of everyone who can play:
+  each signed-in Microsoft account, the offline names the player keeps, and the name the game
+  made up (`horizon-player.txt`). Picking one plays as it from the next Play. Settings > Account
+  adds offline names (3 to 16 letters, digits or `_`; the game gets `--name`) and forgets them;
+  the Console's Share log takes them out of the log too. `horizon-launcher account offline
+  [NAME]`, `account select <name>` (an account or an offline name), `account forget-offline
+  <name>`.
+- **Accent and Home background**: on top of Dark, Light or System, Settings > Launcher picks an
+  accent (Horizon's violet, blue, teal, green, amber, red or pink) and a picture of the player's
+  own behind Home (PNG, JPEG or WebP, cropped to fill; **Landscape** brings Horizon's back). An
+  accent turns the violet tokens to its hue, then darkens or lightens them just enough to keep
+  white on the Play button at 4.5:1 and the accent at 3:1 on every background (a test holds every
+  accent in both looks to it). The picture is copied into the data folder.
+  `horizon-launcher settings accent NAME`, `settings background PATH|default`.
+- **Language**: English, French and Russian (the languages Horizon's own game menus have).
+  The window follows the system's language unless the player picks one in Settings > Launcher
+  (each named in itself); a string a table lacks shows in English. The tables are
+  `launcher/lang/<code>.json`, English text to its translation, Horizon's own; a test fails when
+  the code asks `tr("…")` for a string a table lacks, or a table keeps one the code dropped.
+  `horizon-launcher settings language system|en|fr|ru`.
+- **Skin and cape**: each offline name's **Skin…** in Settings > Account shows the front of its
+  skin and cape, takes a skin PNG (64×64, or the older 64×32) and a cape PNG (64×32), and picks
+  classic or slim arms. The launcher keeps copies in its `skins/` folder and gives the game
+  `HORIZON_OFFLINE_SKIN`, `HORIZON_OFFLINE_SKIN_MODEL` and `HORIZON_OFFLINE_CAPE` when that name
+  plays; the game draws the default skins until it reads them. A Microsoft account's skin and
+  cape: coming soon, with sign-in. `horizon-launcher account skin <name> [FILE] [--model
+  classic|slim] [--cape FILE] [--no-skin] [--no-cape]`.
+- **Console**: Home's Console shows the game's output of this run as it comes: a search (every
+  word, any case), Follow to keep the newest line in view, Copy, and Open logs folder. Warnings
+  and errors stand out. **Share log…** uploads the log to [mclo.gs](https://mclo.gs), a paste
+  service for Minecraft logs, only after the player confirms; the home folder, the user name and
+  the account names are taken out first (`horizon_launcher::game_log`), and **Delete it** removes
+  the paste. `horizon-launcher share-log [--instance]` and `unshare-log <id:token>`;
+  `HORIZON_LAUNCHER_PASTE_URL` points it at a test server.
+- **Worlds**: Home lists the selected instance's worlds (picture, mode, version, last played,
+  size). **Back up** zips one into the instance's `backups/` as the game's Make Backup does
+  (`<date>_<time>_<folder>.zip`); **Copy** puts "<name> (1)" beside it; **Delete** moves it to the
+  system's trash after a confirmation; **Open folder**. The same from the command line:
+  `horizon-launcher worlds [list|backup|copy|delete] [--instance <name>]`.
+  **Play** on a world starts the game straight into it. **Data packs** opens the world's
+  `datapacks/` under its row: what is there (and which the game has turned off), **Add data pack…**,
+  and **Remove** (to the trash); a data pack `.zip` dropped on a world goes into it. The game turns
+  a new one on when the world opens. From the command line: `horizon-launcher worlds
+  datapack-list|datapack-add|datapack-remove <world> …`. The Mods page's **Data packs** tab finds
+  them on Modrinth and installs one into the world picked there (`mods search --kind datapack`,
+  `mods install <pack> --world <world>`), saying what of it runs in Horizon.
+- **Packs**: Home lists the selected instance's resource packs and shader packs, each with a switch.
+  The choice is the game's own: `resourcePacks` in options.txt (a pack turned on goes on top, as
+  the game's Resource Packs screen does) and `pickedShaderPack` in `horizon-graphics.txt` (one shader
+  pack at a time). **Add pack…** or a `.zip` / `.hshader` dropped on the section copies it into the
+  right folder; **Remove** turns it off and moves it to the trash after a confirmation. From the
+  command line: `horizon-launcher packs [list|add|on|off|remove] [--kind resource|shader]
+  [--instance <name>]`.
+- **Screenshots**: Home shows the selected instance's newest screenshots (what F2 saves in its
+  `screenshots/` folder) and all of them on request. Clicking one opens it over the window (← and →
+  step through) with **Copy** (the picture, to the clipboard), **Open**, **Show in folder** and
+  **Delete** (to the trash, after a confirmation). From the command line:
+  `horizon-launcher screenshots [list|delete] [--instance <name>]`.
+- **Multiplayer**: Home lists the selected instance's servers, the game's own Multiplayer list
+  (`servers.dat`, each with the picture the game last saw). **Join** starts the game straight into
+  one; **Add server** and **Remove** (after a confirmation) change the file the game reads,
+  keeping every field the launcher doesn't show and the servers joined with Direct Connection. The
+  same from the command line: `horizon-launcher multiplayer [list|add|remove] [--instance <name>]`
+  and `horizon-launcher play --server <address or name>`.
 - **Patch notes**: each release's notes, newest first, with a link to GitHub Sponsors. Quiet "Discord" and "Website" links sit in the footer.
 
 Data lives in the platform's data directory (`~/.local/share/horizon-launcher` on Linux,
@@ -79,8 +196,10 @@ page `servers.json` (the list), `servers/<name>/` (the servers created there) an
 
 - **Settings**: install new Horizon versions automatically (on unless you turn it off; the
   selected version only moves to the new one if you were on the newest), the opening animation,
-  the game's extra command-line arguments, an HTTP proxy for downloads, and the launcher's own
-  version and update state.
+  what the window does while you play (stays by default; Minimise, or Hide on macOS, puts it away
+  when the game starts and brings it back to the front when the game closes; `settings
+  while-playing stay|minimize|hide`), the game's extra command-line arguments, an HTTP proxy for
+  downloads, and the launcher's own version and update state.
 - **Updates**: there is one channel. Every release is published as the release, GitHub's latest,
   once its smoke test passed (docs/release-flow.md), and the launcher installs it. The game
   pre-releases of the old Alpha channel (v0.2.1 on) stay on the Versions page to install
@@ -152,7 +271,7 @@ and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code
     horizon-launcher install <tag|latest>
     horizon-launcher remove <tag>
     horizon-launcher prepare [--minecraft <dir>] [--version <tag>]
-    horizon-launcher play [--version <tag>] [--arg <ARG>]...   start the client; --arg passes an extra argument through (repeatable)
+    horizon-launcher play [--version <tag>] [--instance <name>] [--arg <ARG>]...   start the client; --arg passes an extra argument through (repeatable)
     horizon-launcher server [--dir <dir>] [--version <tag>] [--accept-eula]
     horizon-launcher notes [<tag>]                  patch notes as plain text
     horizon-launcher links                          the Discord, sponsor and website links
@@ -164,6 +283,19 @@ and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code
     horizon-launcher account sign-out <name>
     horizon-launcher account select <name>          play as this account
     horizon-launcher account offline                play without an account
+    horizon-launcher instance [list]                the instances and their game folders (* = Play starts it)
+    horizon-launcher instance create <name> [--copy <instance>]   empty, or a copy of one's worlds, options and packs
+    horizon-launcher instance rename|icon|group <instance> <value>  icon: a block or item name, #rrggbb or none
+    horizon-launcher instance select <instance>     make Play start it
+    horizon-launcher instance version <instance> <tag|latest>   keep it on one installed version, or follow updates
+    horizon-launcher worlds [list] [--instance <name>]        an instance's worlds
+    horizon-launcher worlds backup|copy|delete <world> [--instance <name>]   delete moves it to the trash
+    horizon-launcher packs [list] [--kind resource|shader] [--instance <name>]   resource and shader packs, on or off
+    horizon-launcher packs add <file> | on|off|remove <pack> [--kind shader]
+    horizon-launcher screenshots [list] [--instance <name>]   an instance's screenshots, the newest first
+    horizon-launcher screenshots delete <name> [--instance <name>]   moves it to the trash
+    horizon-launcher multiplayer [list] [--instance <name>]   the servers in an instance's Multiplayer list
+    horizon-launcher multiplayer add <address> [--name <name>] | remove <server>
     horizon-launcher modpack [list]                 the imported packs and their coverage
     horizon-launcher modpack import <pack>          a .mrpack, CurseForge zip or instance folder
     horizon-launcher modpack port <pack> [--from <dir>] [--version <tag>]   get the jars and carry them over
@@ -191,7 +323,10 @@ and don't set `%ERRORLEVEL%` / `$LASTEXITCODE`. Scripts that need the exit code
 `--json` prints JSON where there is something to report (`versions`, `install`, `notes`,
 `next`, `links`, `game-args`, `update --check`, `logs`, `account`, `benchmark`, `data`, `modpack`). Errors go to stderr with exit code 1. `server` runs in the terminal,
 so lines you type reach its console. `HORIZON_LAUNCHER_HOME` replaces the data folder (for
-scripts and tests).
+scripts and tests). Test runs also set `HORIZON_LAUNCHER_TRASH=<folder>` and
+`HORIZON_LAUNCHER_CLIPBOARD=<file>` inside their scratch folders: what Delete would move to the
+system's trash goes into that folder, and what Copy would put on the clipboard is written to that
+file, so a test never touches the real trash or clipboard.
 
 ## AI agents (MCP)
 
diff --git a/launcher/assets/sculk-card-art.webp b/launcher/assets/sculk-card-art.webp
new file mode 100644
index 000000000..13b9e10e4
Binary files /dev/null and b/launcher/assets/sculk-card-art.webp differ
diff --git a/launcher/assets/sculk-logo.webp b/launcher/assets/sculk-logo.webp
new file mode 100644
index 000000000..8877cd1d9
Binary files /dev/null and b/launcher/assets/sculk-logo.webp differ
diff --git a/launcher/lang/fr.json b/launcher/lang/fr.json
new file mode 100644
index 000000000..189577fb3
--- /dev/null
+++ b/launcher/lang/fr.json
@@ -0,0 +1,162 @@
+{
+  "Home": "Accueil",
+  "Mods": "Mods",
+  "Servers": "Serveurs",
+  "Versions": "Versions",
+  "Patch notes": "Notes de version",
+  "Settings": "Paramètres",
+  "Accounts, updates, and the launcher itself.": "Comptes, mises à jour et le launcher lui-même.",
+  "Account": "Compte",
+  "Updates": "Mises à jour",
+  "Launcher": "Launcher",
+  "Network": "Réseau",
+  "Game": "Jeu",
+  "AI": "IA",
+  "About": "À propos",
+  "Install new versions automatically": "Installer les nouvelles versions automatiquement",
+  "Your selected version only changes if you were playing the newest one.": "Votre version choisie ne change que si vous jouiez à la plus récente.",
+  "Appearance": "Apparence",
+  "Dark": "Sombre",
+  "Light": "Clair",
+  "System": "Système",
+  "Dark by default. System follows your computer's light or dark.": "Sombre par défaut. Système suit le mode clair ou sombre de votre ordinateur.",
+  "Language": "Langue",
+  "System follows your computer's language: {language} here. A string not translated yet shows in English.": "Système suit la langue de votre ordinateur : ici {language}. Un texte pas encore traduit s'affiche en anglais.",
+  "While playing": "Pendant le jeu",
+  "Stay": "Rester",
+  "Minimise": "Réduire",
+  "Hide": "Masquer",
+  "The launcher stays open while you play.": "Le launcher reste ouvert pendant que vous jouez.",
+  "The launcher goes down when the game starts, and comes back when it closes.": "Le launcher se réduit quand le jeu démarre et revient quand il se ferme.",
+  "The launcher hides when the game starts, and comes back when it closes.": "Le launcher se masque quand le jeu démarre et revient quand il se ferme.",
+  "Show the opening": "Afficher l'ouverture",
+  "The wordmark, while the release list loads.": "Le logo, pendant que la liste des versions se charge.",
+  "{version} available": "{version} disponible",
+  "Up to date": "À jour",
+  "up to date": "à jour",
+  "Checking…": "Vérification…",
+  "downloading {version}, {percent}%": "téléchargement de {version}, {percent} %",
+  "Updated to {version}. Restart the launcher to use it.": "Mis à jour vers {version}. Redémarrez le launcher pour l'utiliser.",
+  "the update failed: {error}": "la mise à jour a échoué : {error}",
+  "Install": "Installer",
+  "Restart": "Redémarrer",
+  "Check now": "Vérifier",
+  "Open": "Ouvrir",
+  "Data folder": "Dossier des données",
+  "Logs": "Journaux",
+  "crash reports beside it": "rapports de plantage à côté",
+  "Applications menu": "Menu des applications",
+  "Horizon and its icon are in your desktop's menu.": "Horizon et son icône sont dans le menu de votre bureau.",
+  "Not in your desktop's menu.": "Pas dans le menu de votre bureau.",
+  "Microsoft account (coming soon)": "Compte Microsoft (bientôt)",
+  "Microsoft account": "Compte Microsoft",
+  "Another account": "Un autre compte",
+  "Microsoft sign-in is coming soon. Until then the game plays offline: single player, LAN and servers in offline mode work.": "La connexion Microsoft arrive bientôt. D'ici là, le jeu se joue hors ligne : solo, LAN et serveurs en mode hors ligne fonctionnent.",
+  "Coming soon": "Bientôt",
+  "Microsoft account · plays": "Compte Microsoft · joue",
+  "Microsoft account · signed in": "Compte Microsoft · connecté",
+  "Asking Microsoft…": "Demande à Microsoft…",
+  "Add another account.": "Ajoutez un autre compte.",
+  "Copy code": "Copier le code",
+  "Open link": "Ouvrir le lien",
+  "Play as": "Jouer en tant que",
+  "Play offline": "Jouer hors ligne",
+  "Sign out": "Se déconnecter",
+  "Offline": "Hors ligne",
+  "Microsoft": "Microsoft",
+  "Offline, the game's name": "Hors ligne, le nom du jeu",
+  "Manage accounts": "Gérer les comptes",
+  "Offline name": "Nom hors ligne",
+  "Offline name · plays": "Nom hors ligne · joue",
+  "A name, 3 to 16 letters": "Un nom, de 3 à 16 lettres",
+  "Play offline under another name, and switch from the top bar. Online servers don't take offline names.": "Jouez hors ligne sous un autre nom, et changez depuis la barre du haut. Les serveurs en ligne n'acceptent pas les noms hors ligne.",
+  "Add": "Ajouter",
+  "Skin…": "Skin…",
+  "Forget": "Oublier",
+  "{name}'s skin": "Skin de {name}",
+  "{name}'s skin is kept.": "Le skin de {name} est enregistré.",
+  "{name}'s cape is kept.": "La cape de {name} est enregistrée.",
+  "Choose a skin…": "Choisir un skin…",
+  "Default skin": "Skin par défaut",
+  "Classic arms": "Bras classiques",
+  "Slim arms": "Bras fins",
+  "Choose a cape…": "Choisir une cape…",
+  "No cape": "Pas de cape",
+  "Default": "Par défaut",
+  "A 64×64 (or 64×32) skin PNG and a 64×32 cape PNG, kept by the launcher and given to the game when this name plays. The game draws the default skins for now; it uses these once it can. A Microsoft account's skin and cape: coming soon.": "Un PNG de skin 64×64 (ou 64×32) et un PNG de cape 64×32, gardés par le launcher et donnés au jeu quand ce nom joue. Le jeu dessine encore les skins par défaut ; il utilisera ceux-ci dès qu'il le pourra. Skin et cape d'un compte Microsoft : bientôt.",
+  "Accent colour": "Couleur d'accent",
+  "Horizon's violet by default. Every colour keeps text as easy to read.": "Le violet d'Horizon par défaut. Chaque couleur garde le texte aussi lisible.",
+  "Choose": "Choisir",
+  "Choose a picture…": "Choisir une image…",
+  "Landscape": "Paysage",
+  "Your picture, behind Home, cropped to fill it.": "Votre image, derrière l'accueil, recadrée pour le remplir.",
+  "Horizon's landscape. Pick a PNG, JPEG or WebP picture of your own.": "Le paysage d'Horizon. Choisissez votre propre image PNG, JPEG ou WebP.",
+  "Home background": "Fond de l'accueil",
+  "Play": "Jouer",
+  "Running": "En cours",
+  "Stopped": "Arrêté",
+  "Start the game, or run a server for others to join.": "Lancez le jeu, ou ouvrez un serveur que d'autres peuvent rejoindre.",
+  "No version installed yet.": "Aucune version installée pour l'instant.",
+  "Choose a version": "Choisir une version",
+  "Host a server": "Héberger un serveur",
+  "Preparing…": "Préparation…",
+  "Prepare": "Préparer",
+  "Prepare again": "Préparer à nouveau",
+  "Not found. Choose the folder where your launcher keeps Minecraft.": "Introuvable. Choisissez le dossier où votre launcher garde Minecraft.",
+  "Ready to play": "Prêt à jouer",
+  "Resources": "Ressources",
+  "Minecraft folder": "Dossier Minecraft",
+  "Choose…": "Choisir…",
+  "Playing offline": "Jeu hors ligne",
+  "Online servers need a Microsoft account.": "Les serveurs en ligne demandent un compte Microsoft.",
+  "Accounts…": "Comptes…",
+  "The first preparation takes a few minutes.": "La première préparation prend quelques minutes.",
+  "Horizon crashed": "Horizon a planté",
+  "When you report it on Discord, attach the crash report file (or paste it with Copy report) and say what you were doing.": "Pour le signaler sur Discord, joignez le rapport de plantage (ou collez-le avec Copier le rapport) et dites ce que vous faisiez.",
+  "The game ended without a crash report. When you report it on Discord, attach latest.log from the logs folder and say what you were doing.": "Le jeu s'est arrêté sans rapport de plantage. Pour le signaler sur Discord, joignez latest.log du dossier des journaux et dites ce que vous faisiez.",
+  "Open report": "Ouvrir le rapport",
+  "Copied": "Copié",
+  "Copy report": "Copier le rapport",
+  "Open logs folder": "Ouvrir le dossier des journaux",
+  "Report on Discord": "Signaler sur Discord",
+  "Dismiss": "Fermer",
+  "INSTANCES": "INSTANCES",
+  "SERVERS": "SERVEURS",
+  "HIDE": "MASQUER",
+  "Website": "Site web",
+  "Ready": "Prêt",
+  "Needs preparing": "À préparer",
+  "{version} is not installed": "{version} n'est pas installée",
+  "No version installed": "Aucune version installée",
+  "Modpack": "Modpack",
+  "From Horizon's registry": "Du registre d'Horizon",
+  "Instance": "Instance",
+  "Edit…": "Modifier…",
+  "Copy…": "Copier…",
+  "Export…": "Exporter…",
+  "Close export": "Fermer l'export",
+  "Launch…": "Lancement…",
+  "Close launch": "Fermer le lancement",
+  "Open folder": "Ouvrir le dossier",
+  "Join a friend": "Rejoindre un ami",
+  "Paste an invite code": "Collez un code d'invitation",
+  "Paste the code a friend shows when they invite you.": "Collez le code qu'un ami affiche quand il vous invite.",
+  "Join": "Rejoindre",
+  "Shortcut": "Raccourci",
+  "Remove shortcut": "Retirer le raccourci",
+  "today": "aujourd'hui",
+  "yesterday": "hier",
+  "{days} days ago": "il y a {days} jours",
+  "{time} in total · last played {when}": "{time} au total · joué pour la dernière fois {when}",
+  "Not played yet": "Pas encore joué",
+  "under a minute": "moins d'une minute",
+  "PARTNER": "PARTENAIRE",
+  "Your Minecraft server, {online}.": "Votre serveur Minecraft, {online}.",
+  "24/7 online": "en ligne 24h/24",
+  "Ready in under a minute": "Prêt en moins d'une minute",
+  "Get my server": "Obtenir mon serveur",
+  "15% off": "-15 %",
+  "Not prepared. Horizon needs the files of your own Minecraft {version}.": "Pas préparé. Horizon a besoin des fichiers de votre propre Minecraft {version}.",
+  "Prepared for Minecraft {version}": "Préparé pour Minecraft {version}",
+  "Prepared for Minecraft {version}, without its sounds: the game will be silent. Prepare again to copy them from your Minecraft install.": "Préparé pour Minecraft {version}, sans ses sons : le jeu sera muet. Préparez à nouveau pour les copier depuis votre installation de Minecraft."
+}
diff --git a/launcher/lang/ru.json b/launcher/lang/ru.json
new file mode 100644
index 000000000..a992ef819
--- /dev/null
+++ b/launcher/lang/ru.json
@@ -0,0 +1,162 @@
+{
+  "Home": "Главная",
+  "Mods": "Моды",
+  "Servers": "Серверы",
+  "Versions": "Версии",
+  "Patch notes": "Список изменений",
+  "Settings": "Настройки",
+  "Accounts, updates, and the launcher itself.": "Аккаунты, обновления и сам лаунчер.",
+  "Account": "Аккаунт",
+  "Updates": "Обновления",
+  "Launcher": "Лаунчер",
+  "Network": "Сеть",
+  "Game": "Игра",
+  "AI": "ИИ",
+  "About": "О программе",
+  "Install new versions automatically": "Устанавливать новые версии автоматически",
+  "Your selected version only changes if you were playing the newest one.": "Выбранная версия меняется, только если вы играли в самую новую.",
+  "Appearance": "Оформление",
+  "Dark": "Тёмное",
+  "Light": "Светлое",
+  "System": "Системное",
+  "Dark by default. System follows your computer's light or dark.": "По умолчанию тёмное. «Системное» следует светлой или тёмной теме компьютера.",
+  "Language": "Язык",
+  "System follows your computer's language: {language} here. A string not translated yet shows in English.": "«Системный» следует языку компьютера: здесь {language}. Ещё не переведённый текст показывается по-английски.",
+  "While playing": "Во время игры",
+  "Stay": "Оставаться",
+  "Minimise": "Свернуть",
+  "Hide": "Скрыть",
+  "The launcher stays open while you play.": "Лаунчер остаётся открытым, пока вы играете.",
+  "The launcher goes down when the game starts, and comes back when it closes.": "Лаунчер сворачивается при запуске игры и возвращается, когда она закрывается.",
+  "The launcher hides when the game starts, and comes back when it closes.": "Лаунчер скрывается при запуске игры и возвращается, когда она закрывается.",
+  "Show the opening": "Показывать заставку",
+  "The wordmark, while the release list loads.": "Логотип, пока загружается список версий.",
+  "{version} available": "Доступна {version}",
+  "Up to date": "Обновлено",
+  "up to date": "обновлено",
+  "Checking…": "Проверка…",
+  "downloading {version}, {percent}%": "загрузка {version}, {percent}%",
+  "Updated to {version}. Restart the launcher to use it.": "Обновлено до {version}. Перезапустите лаунчер, чтобы применить.",
+  "the update failed: {error}": "обновление не удалось: {error}",
+  "Install": "Установить",
+  "Restart": "Перезапустить",
+  "Check now": "Проверить",
+  "Open": "Открыть",
+  "Data folder": "Папка данных",
+  "Logs": "Журналы",
+  "crash reports beside it": "отчёты о сбоях рядом",
+  "Applications menu": "Меню приложений",
+  "Horizon and its icon are in your desktop's menu.": "Horizon и его значок есть в меню рабочего стола.",
+  "Not in your desktop's menu.": "Нет в меню рабочего стола.",
+  "Microsoft account (coming soon)": "Аккаунт Microsoft (скоро)",
+  "Microsoft account": "Аккаунт Microsoft",
+  "Another account": "Другой аккаунт",
+  "Microsoft sign-in is coming soon. Until then the game plays offline: single player, LAN and servers in offline mode work.": "Вход через Microsoft скоро появится. А пока игра работает офлайн: одиночная игра, LAN и серверы в офлайн-режиме.",
+  "Coming soon": "Скоро",
+  "Microsoft account · plays": "Аккаунт Microsoft · играет",
+  "Microsoft account · signed in": "Аккаунт Microsoft · вход выполнен",
+  "Asking Microsoft…": "Запрос к Microsoft…",
+  "Add another account.": "Добавьте ещё один аккаунт.",
+  "Copy code": "Скопировать код",
+  "Open link": "Открыть ссылку",
+  "Play as": "Играть за",
+  "Play offline": "Играть офлайн",
+  "Sign out": "Выйти",
+  "Offline": "Офлайн",
+  "Microsoft": "Microsoft",
+  "Offline, the game's name": "Офлайн, имя от игры",
+  "Manage accounts": "Управление аккаунтами",
+  "Offline name": "Офлайн-имя",
+  "Offline name · plays": "Офлайн-имя · играет",
+  "A name, 3 to 16 letters": "Имя, от 3 до 16 букв",
+  "Play offline under another name, and switch from the top bar. Online servers don't take offline names.": "Играйте офлайн под другим именем и переключайтесь в верхней панели. Онлайн-серверы не принимают офлайн-имена.",
+  "Add": "Добавить",
+  "Skin…": "Скин…",
+  "Forget": "Забыть",
+  "{name}'s skin": "Скин {name}",
+  "{name}'s skin is kept.": "Скин {name} сохранён.",
+  "{name}'s cape is kept.": "Плащ {name} сохранён.",
+  "Choose a skin…": "Выбрать скин…",
+  "Default skin": "Скин по умолчанию",
+  "Classic arms": "Обычные руки",
+  "Slim arms": "Тонкие руки",
+  "Choose a cape…": "Выбрать плащ…",
+  "No cape": "Без плаща",
+  "Default": "По умолчанию",
+  "A 64×64 (or 64×32) skin PNG and a 64×32 cape PNG, kept by the launcher and given to the game when this name plays. The game draws the default skins for now; it uses these once it can. A Microsoft account's skin and cape: coming soon.": "PNG скина 64×64 (или 64×32) и PNG плаща 64×32 хранятся в лаунчере и передаются игре, когда играет это имя. Пока игра рисует стандартные скины; она начнёт использовать эти, как только сможет. Скин и плащ аккаунта Microsoft: скоро.",
+  "Accent colour": "Цвет акцента",
+  "Horizon's violet by default. Every colour keeps text as easy to read.": "По умолчанию фиолетовый Horizon. С любым цветом текст читается так же легко.",
+  "Choose": "Выбрать",
+  "Choose a picture…": "Выбрать картинку…",
+  "Landscape": "Пейзаж",
+  "Your picture, behind Home, cropped to fill it.": "Ваша картинка за главной страницей, обрезанная по размеру.",
+  "Horizon's landscape. Pick a PNG, JPEG or WebP picture of your own.": "Пейзаж Horizon. Выберите свою картинку PNG, JPEG или WebP.",
+  "Home background": "Фон главной",
+  "Play": "Играть",
+  "Running": "Запущено",
+  "Stopped": "Остановлен",
+  "Start the game, or run a server for others to join.": "Запустите игру или сервер, к которому смогут подключиться другие.",
+  "No version installed yet.": "Пока не установлено ни одной версии.",
+  "Choose a version": "Выбрать версию",
+  "Host a server": "Открыть сервер",
+  "Preparing…": "Подготовка…",
+  "Prepare": "Подготовить",
+  "Prepare again": "Подготовить заново",
+  "Not found. Choose the folder where your launcher keeps Minecraft.": "Не найдено. Выберите папку, где ваш лаунчер хранит Minecraft.",
+  "Ready to play": "Готово к игре",
+  "Resources": "Ресурсы",
+  "Minecraft folder": "Папка Minecraft",
+  "Choose…": "Выбрать…",
+  "Playing offline": "Игра офлайн",
+  "Online servers need a Microsoft account.": "Для онлайн-серверов нужен аккаунт Microsoft.",
+  "Accounts…": "Аккаунты…",
+  "The first preparation takes a few minutes.": "Первая подготовка занимает несколько минут.",
+  "Horizon crashed": "Horizon вылетел",
+  "When you report it on Discord, attach the crash report file (or paste it with Copy report) and say what you were doing.": "Сообщая об этом в Discord, приложите файл отчёта о сбое (или вставьте его через «Скопировать отчёт») и расскажите, что вы делали.",
+  "The game ended without a crash report. When you report it on Discord, attach latest.log from the logs folder and say what you were doing.": "Игра закрылась без отчёта о сбое. Сообщая об этом в Discord, приложите latest.log из папки журналов и расскажите, что вы делали.",
+  "Open report": "Открыть отчёт",
+  "Copied": "Скопировано",
+  "Copy report": "Скопировать отчёт",
+  "Open logs folder": "Открыть папку журналов",
+  "Report on Discord": "Сообщить в Discord",
+  "Dismiss": "Закрыть",
+  "INSTANCES": "СБОРКИ",
+  "SERVERS": "СЕРВЕРЫ",
+  "HIDE": "СКРЫТЬ",
+  "Website": "Сайт",
+  "Ready": "Готово",
+  "Needs preparing": "Нужна подготовка",
+  "{version} is not installed": "{version} не установлена",
+  "No version installed": "Версия не установлена",
+  "Modpack": "Сборка модов",
+  "From Horizon's registry": "Из каталога Horizon",
+  "Instance": "Сборка",
+  "Edit…": "Изменить…",
+  "Copy…": "Копировать…",
+  "Export…": "Экспорт…",
+  "Close export": "Закрыть экспорт",
+  "Launch…": "Запуск…",
+  "Close launch": "Закрыть запуск",
+  "Open folder": "Открыть папку",
+  "Join a friend": "Присоединиться к другу",
+  "Paste an invite code": "Вставьте код приглашения",
+  "Paste the code a friend shows when they invite you.": "Вставьте код, который друг показывает, когда приглашает вас.",
+  "Join": "Войти",
+  "Shortcut": "Ярлык",
+  "Remove shortcut": "Убрать ярлык",
+  "today": "сегодня",
+  "yesterday": "вчера",
+  "{days} days ago": "{days} дн. назад",
+  "{time} in total · last played {when}": "всего {time} · последняя игра: {when}",
+  "Not played yet": "Ещё не запускалась",
+  "under a minute": "меньше минуты",
+  "PARTNER": "ПАРТНЁР",
+  "Your Minecraft server, {online}.": "Ваш сервер Minecraft, {online}.",
+  "24/7 online": "онлайн 24/7",
+  "Ready in under a minute": "Готов меньше чем за минуту",
+  "Get my server": "Получить сервер",
+  "15% off": "скидка 15%",
+  "Not prepared. Horizon needs the files of your own Minecraft {version}.": "Не подготовлено. Horizon нужны файлы вашего собственного Minecraft {version}.",
+  "Prepared for Minecraft {version}": "Подготовлено для Minecraft {version}",
+  "Prepared for Minecraft {version}, without its sounds: the game will be silent. Prepare again to copy them from your Minecraft install.": "Подготовлено для Minecraft {version}, но без звуков: игра будет беззвучной. Подготовьте заново, чтобы скопировать их из вашей установки Minecraft."
+}
diff --git a/launcher/src/account.rs b/launcher/src/account.rs
index 1416424ce..257055911 100644
--- a/launcher/src/account.rs
+++ b/launcher/src/account.rs
@@ -638,6 +638,33 @@ pub struct Accounts {
     pub accounts: Vec<Account>,
     /// The UUID of the account the game starts with; none plays offline.
     pub selected: Option<String>,
+    /// Offline names the player keeps, to switch between (`--name`): no account, no skin.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub offline: Vec<String>,
+    /// The offline name that plays when no account is selected; none: the name the game made up
+    /// (`horizon-player.txt`).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offline_selected: Option<String>,
+    /// Each offline name's skin and cape (`skins`), by the name in lowercase.
+    #[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
+    pub looks: std::collections::BTreeMap<String, crate::skins::Look>,
+}
+
+/// Who plays, as the quick switch lists them.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Player {
+    /// A Microsoft account, by UUID.
+    Microsoft(String),
+    /// An offline name.
+    Offline(String),
+    /// Offline as the name the game made up.
+    GameName,
+}
+
+/// Whether `name` can be an offline name: 3 to 16 letters, digits or `_`, as account names are.
+pub fn valid_offline_name(name: &str) -> bool {
+    (3..=16).contains(&name.chars().count())
+        && name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_')
 }
 
 impl Accounts {
@@ -687,6 +714,94 @@ impl Accounts {
         }
         Ok(())
     }
+    /// Who plays now.
+    pub fn player(&self) -> Player {
+        match (self.selected(), &self.offline_selected) {
+            (Some(a), _) => Player::Microsoft(a.uuid.clone()),
+            (None, Some(name)) => Player::Offline(name.clone()),
+            (None, None) => Player::GameName,
+        }
+    }
+
+    /// Plays as `who`: an account, an offline name (kept), or the game's own name.
+    pub fn play_as(&mut self, who: Player) -> Result<(), String> {
+        match who {
+            Player::Microsoft(uuid) => {
+                if !self.accounts.iter().any(|a| a.uuid == uuid) {
+                    return Err("That account isn't signed in.".into());
+                }
+                self.selected = Some(uuid);
+            }
+            Player::Offline(name) => {
+                let name = self.add_offline(&name)?;
+                self.selected = None;
+                self.offline_selected = Some(name);
+            }
+            Player::GameName => {
+                self.selected = None;
+                self.offline_selected = None;
+            }
+        }
+        Ok(())
+    }
+
+    /// Keeps an offline name (once, in any case); returns it as kept.
+    pub fn add_offline(&mut self, name: &str) -> Result<String, String> {
+        let name = name.trim();
+        if !valid_offline_name(name) {
+            return Err(format!(
+                "{name}: an offline name is 3 to 16 letters, digits or _"
+            ));
+        }
+        if let Some(kept) = self.offline.iter().find(|n| n.eq_ignore_ascii_case(name)) {
+            return Ok(kept.clone());
+        }
+        self.offline.push(name.to_string());
+        Ok(name.to_string())
+    }
+
+    /// Forgets an offline name; if it was playing, the game's own name plays.
+    pub fn remove_offline(&mut self, name: &str) -> Result<(), String> {
+        let before = self.offline.len();
+        self.offline.retain(|n| !n.eq_ignore_ascii_case(name));
+        self.looks.remove(&name.to_ascii_lowercase());
+        if self.offline.len() == before {
+            return Err(format!("No offline name {name}."));
+        }
+        if self
+            .offline_selected
+            .as_ref()
+            .is_some_and(|n| n.eq_ignore_ascii_case(name))
+        {
+            self.offline_selected = None;
+        }
+        Ok(())
+    }
+
+    /// An offline name's look (the default: no skin of its own).
+    pub fn look(&self, name: &str) -> crate::skins::Look {
+        self.looks
+            .get(&name.to_ascii_lowercase())
+            .cloned()
+            .unwrap_or_default()
+    }
+
+    /// The game's variables for the offline name that plays: its skin and cape.
+    pub fn look_env(&self) -> Vec<(&'static str, String)> {
+        match self.name_arg() {
+            Some(name) => crate::skins::env(&crate::skins::dir(), name, &self.look(name)),
+            None => Vec::new(),
+        }
+    }
+
+    /// The game's `--name` for this run: the offline name, when one plays.
+    pub fn name_arg(&self) -> Option<&str> {
+        match self.selected() {
+            Some(_) => None,
+            None => self.offline_selected.as_deref(),
+        }
+    }
+
     /// Sign out: the secrets leave the keychain, the account the list.
     pub fn remove(&mut self, store: &dyn SecretStore, uuid: &str) -> Result<(), String> {
         store.delete(uuid)?;
diff --git a/launcher/src/account/tests.rs b/launcher/src/account/tests.rs
index 5aea5dd12..ec3766c7e 100644
--- a/launcher/src/account/tests.rs
+++ b/launcher/src/account/tests.rs
@@ -423,3 +423,43 @@ fn client_id_is_configuration() {
     );
     std::env::remove_var("HORIZON_MSA_CLIENT_ID");
 }
+
+#[test]
+fn offline_names_switch_with_accounts() {
+    let mut a = Accounts {
+        accounts: vec![Account {
+            uuid: "abc".into(),
+            name: "Ludo".into(),
+            skin: None,
+            cape: None,
+        }],
+        selected: Some("abc".into()),
+        ..Accounts::default()
+    };
+    assert_eq!(a.player(), Player::Microsoft("abc".into()));
+    assert_eq!(a.name_arg(), None);
+    a.play_as(Player::Offline("Builder_1".into())).unwrap();
+    assert_eq!(a.player(), Player::Offline("Builder_1".into()));
+    assert_eq!(a.name_arg(), Some("Builder_1"));
+    // Kept once, as first written, whatever the case.
+    a.play_as(Player::Offline("builder_1".into())).unwrap();
+    assert_eq!(a.offline, ["Builder_1"]);
+    assert_eq!(a.name_arg(), Some("Builder_1"));
+    assert!(a.add_offline("no spaces").is_err());
+    assert!(a.add_offline("ab").is_err());
+    assert!(a.add_offline("seventeen_letters").is_err());
+    a.play_as(Player::Microsoft("abc".into())).unwrap();
+    assert_eq!(a.name_arg(), None, "an account plays with its own name");
+    assert!(a.play_as(Player::Microsoft("zzz".into())).is_err());
+    a.play_as(Player::Offline("Builder_1".into())).unwrap();
+    a.remove_offline("BUILDER_1").unwrap();
+    assert_eq!(a.player(), Player::GameName);
+    assert!(a.remove_offline("Builder_1").is_err());
+    // An accounts.json from before offline names reads as it was, and writes nothing new.
+    let old: Accounts = serde_json::from_str(r#"{"accounts":[],"selected":null}"#).unwrap();
+    assert_eq!(old.player(), Player::GameName);
+    assert_eq!(
+        serde_json::to_string(&old).unwrap(),
+        r#"{"accounts":[],"selected":null}"#
+    );
+}
diff --git a/launcher/src/agents_page.rs b/launcher/src/agents_page.rs
index e53d6550a..aae76b6f9 100644
--- a/launcher/src/agents_page.rs
+++ b/launcher/src/agents_page.rs
@@ -77,7 +77,7 @@ impl Launcher {
                 &t,
             )
             .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
-                cx.write_to_clipboard(gpui::ClipboardItem::new_string(text.clone()));
+                copy_to_clipboard(cx, gpui::ClipboardItem::new_string(text.clone()));
                 this.agents.copied = Some(id);
                 cx.notify();
             }))
diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs
index 85818a67c..17840fe90 100644
--- a/launcher/src/backend.rs
+++ b/launcher/src/backend.rs
@@ -651,14 +651,17 @@ fn sounds_in(resources: &Path) -> bool {
 
 /// What the Play page says of a version's resources.
 pub fn resources_summary(prepared: bool, sounds: bool, version: &str) -> String {
+    use crate::i18n::trf;
     match (prepared, sounds) {
-        (false, _) => {
-            format!("Not prepared. Horizon needs the files of your own Minecraft {version}.")
-        }
-        (true, true) => format!("Prepared for Minecraft {version}"),
-        (true, false) => format!(
+        (false, _) => trf(
+            "Not prepared. Horizon needs the files of your own Minecraft {version}.",
+            &[("version", version)],
+        ),
+        (true, true) => trf("Prepared for Minecraft {version}", &[("version", version)]),
+        (true, false) => trf(
             "Prepared for Minecraft {version}, without its sounds: the game will be silent. \
-             Prepare again to copy them from your Minecraft install."
+             Prepare again to copy them from your Minecraft install.",
+            &[("version", version)],
         ),
     }
 }
@@ -1585,9 +1588,10 @@ pub fn newest_crash_report() -> Option<PathBuf> {
     crash_reports_in(&crash_reports_dir()).pop()
 }
 
-/// The newest crash report written at or after `since` (one from the run that started then).
-pub fn crash_report_since(since: std::time::SystemTime) -> Option<PathBuf> {
-    crash_report_in_since(&crash_reports_dir(), since)
+/// The newest crash report the game playing in `home` wrote at or after `since` (one from the
+/// run that started then).
+pub fn crash_report_since(home: &Path, since: std::time::SystemTime) -> Option<PathBuf> {
+    crash_report_in_since(&home.join("crash-reports"), since)
 }
 
 fn crash_report_in_since(dir: &Path, since: std::time::SystemTime) -> Option<PathBuf> {
@@ -2514,9 +2518,57 @@ pub enum Appearance {
     System,
 }
 
+/// What the launcher's window does while the game runs, as the player picks it in Settings.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum WhilePlaying {
+    /// The window stays where it is.
+    #[default]
+    Stay,
+    /// The window goes to the Dock or the taskbar, and comes back when the game closes.
+    Minimize,
+    /// The launcher hides (macOS only: elsewhere it minimises), and comes back when the game
+    /// closes.
+    Hide,
+}
+
+impl WhilePlaying {
+    pub const ALL: [WhilePlaying; 3] = [Self::Stay, Self::Minimize, Self::Hide];
+
+    /// Its name in `settings.json` and on the command line.
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Stay => "stay",
+            Self::Minimize => "minimize",
+            Self::Hide => "hide",
+        }
+    }
+
+    pub fn parse(name: &str) -> Option<Self> {
+        let name = name.trim().to_ascii_lowercase();
+        let name = match name.as_str() {
+            "minimise" => "minimize",
+            "keep" | "open" | "off" => "stay",
+            n => n,
+        };
+        Self::ALL.into_iter().find(|w| w.name() == name)
+    }
+
+    /// What this computer does for it: only macOS can hide a whole app.
+    pub fn here(self) -> Self {
+        match self {
+            Self::Hide if !cfg!(target_os = "macos") => Self::Minimize,
+            w => w,
+        }
+    }
+}
+
 #[derive(Default, serde::Serialize, serde::Deserialize)]
 pub struct Settings {
     pub selected: Option<String>,
+    /// The instance Play starts (`instances`), by id. Unset means Horizon, the game's home.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub instance: Option<String>,
     pub minecraft_dir: Option<PathBuf>,
     pub server_dir: Option<PathBuf>,
     /// Unset means on: only a player who turned it off has `false` here. 0.1.1 wrote its
@@ -2545,6 +2597,26 @@ pub struct Settings {
     /// first-run question, or on the Play page once if they answered that before it existed.
     #[serde(default)]
     pub ping_notice_seen: bool,
+    /// Seconds the sidebar's partner banner has been on screen, over every start, up to
+    /// `partner::SEEN_BEFORE_HIDE`: only then can the player hide it.
+    #[serde(default)]
+    pub partner_seen_secs: u64,
+    /// The player hid the sidebar's partner banner. The Servers page keeps its own.
+    #[serde(default)]
+    pub partner_hidden: bool,
+    /// What the window does while the game runs. Stays by default.
+    #[serde(default)]
+    pub while_playing: WhilePlaying,
+    /// The accent colour on top of the appearance (`themes::Accent`). Horizon's violet by default.
+    #[serde(default)]
+    pub accent: crate::themes::Accent,
+    /// Home's background: a picture the player picked, kept in the data folder under this name
+    /// (`themes::keep_background`). Unset shows Horizon's landscape.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub background: Option<String>,
+    /// The window's language. Unset follows the system's (`i18n::Language::system`).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<crate::i18n::Language>,
 }
 
 impl Settings {
@@ -2563,6 +2635,23 @@ impl Settings {
             {
                 fields.remove("appearance");
             }
+            if fields
+                .get("while_playing")
+                .is_some_and(|w| serde_json::from_value::<WhilePlaying>(w.clone()).is_err())
+            {
+                fields.remove("while_playing");
+            }
+            if fields.get("accent").is_some_and(|a| {
+                serde_json::from_value::<crate::themes::Accent>(a.clone()).is_err()
+            }) {
+                fields.remove("accent");
+            }
+            // A language this launcher doesn't have yet follows the system's.
+            if fields.get("language").is_some_and(|l| {
+                serde_json::from_value::<Option<crate::i18n::Language>>(l.clone()).is_err()
+            }) {
+                fields.remove("language");
+            }
         }
         serde_json::from_value(value).unwrap_or_default()
     }
@@ -2570,6 +2659,10 @@ impl Settings {
     pub fn desktop_entry(&self) -> bool {
         self.desktop_entry.unwrap_or(true)
     }
+    /// The window's language: the one picked, else the system's.
+    pub fn language(&self) -> crate::i18n::Language {
+        self.language.unwrap_or_else(crate::i18n::Language::system)
+    }
     /// Whether new Horizon versions are installed automatically.
     pub fn auto_install(&self) -> bool {
         self.install_new_versions.unwrap_or(true)
@@ -2876,6 +2969,59 @@ mod tests {
         assert_eq!(CHECK_EVERY.as_secs(), 30 * 60);
     }
 
+    #[test]
+    fn the_window_stays_while_playing_unless_picked() {
+        assert_eq!(Settings::parse("{}").while_playing, WhilePlaying::Stay);
+        let hide = Settings::parse(r#"{"while_playing": "hide", "game_args": "--x"}"#);
+        assert_eq!(hide.while_playing, WhilePlaying::Hide);
+        let future = Settings::parse(r#"{"while_playing": "fade", "game_args": "--x"}"#);
+        assert_eq!(
+            (future.while_playing, future.game_args.as_str()),
+            (WhilePlaying::Stay, "--x")
+        );
+        assert_eq!(
+            WhilePlaying::parse("Minimise"),
+            Some(WhilePlaying::Minimize)
+        );
+        assert_eq!(WhilePlaying::parse("off"), Some(WhilePlaying::Stay));
+        assert_eq!(WhilePlaying::parse("close"), None);
+        for w in WhilePlaying::ALL {
+            let text = serde_json::to_string(&w).unwrap();
+            assert_eq!(text, format!("\"{}\"", w.name()));
+        }
+        let here = WhilePlaying::Hide.here();
+        assert_eq!(here == WhilePlaying::Hide, cfg!(target_os = "macos"));
+    }
+
+    #[test]
+    fn the_language_follows_the_system_unless_picked() {
+        use crate::i18n::Language;
+        assert_eq!(Settings::parse("{}").language, None);
+        let fr = Settings::parse(r#"{"language": "fr"}"#);
+        assert_eq!(fr.language(), Language::French);
+        let future = Settings::parse(r#"{"language": "eo", "game_args": "--x"}"#);
+        assert_eq!((future.language, future.game_args.as_str()), (None, "--x"));
+        let saved = serde_json::to_value(Settings::default()).unwrap();
+        assert!(saved.get("language").is_none(), "unset is left out");
+    }
+
+    #[test]
+    fn the_accent_is_violet_unless_picked_and_an_unknown_one_keeps_the_rest() {
+        use crate::themes::Accent;
+        assert_eq!(Settings::parse("{}").accent, Accent::Violet);
+        let teal =
+            Settings::parse(r#"{"accent": "teal", "background": "background-0123456789ab.png"}"#);
+        assert_eq!(
+            (teal.accent, teal.background.as_deref()),
+            (Accent::Teal, Some("background-0123456789ab.png"))
+        );
+        let future = Settings::parse(r#"{"accent": "plaid", "game_args": "--x"}"#);
+        assert_eq!(
+            (future.accent, future.game_args.as_str()),
+            (Accent::Violet, "--x")
+        );
+    }
+
     #[test]
     fn the_appearance_is_dark_unless_picked_and_an_unknown_one_keeps_the_rest() {
         assert_eq!(Settings::parse("{}").appearance, Appearance::Dark);
diff --git a/launcher/src/browser.rs b/launcher/src/browser.rs
index 295ba3c08..4d8bc5be4 100644
--- a/launcher/src/browser.rs
+++ b/launcher/src/browser.rs
@@ -3,8 +3,9 @@
 //! matches (docs/mod-browser.md).
 //!
 //! Offered: Java mods (Fabric, NeoForge, Forge), whose content Horizon ports and whose jar is
-//! checked before install ([`java`]), modpacks (imported and ported) and resource packs
-//! (`resourcepacks/`). Java code itself doesn't run in Horizon (docs/mods.md).
+//! checked before install ([`java`]), modpacks (imported and ported), resource packs
+//! (`resourcepacks/`) and data packs (into a world, [`installed::install_datapack`]). Java code
+//! itself doesn't run in Horizon (docs/mods.md).
 pub mod curseforge;
 pub mod details;
 pub mod download;
@@ -31,10 +32,18 @@ pub enum Kind {
     /// One of Horizon's own shader packs (`.hshader`, docs/shaders.md), from Horizon's registry
     /// only.
     Shader,
+    /// A data pack: it goes into one world's `datapacks/` (`crate::datapacks`).
+    DataPack,
 }
 
 impl Kind {
-    pub const ALL: [Kind; 4] = [Kind::Mod, Kind::Modpack, Kind::ResourcePack, Kind::Shader];
+    pub const ALL: [Kind; 5] = [
+        Kind::Mod,
+        Kind::Modpack,
+        Kind::ResourcePack,
+        Kind::Shader,
+        Kind::DataPack,
+    ];
 
     pub fn label(self) -> &'static str {
         match self {
@@ -42,16 +51,17 @@ impl Kind {
             Kind::ResourcePack => "Resource packs",
             Kind::Modpack => "Modpacks",
             Kind::Shader => "Shader packs",
+            Kind::DataPack => "Data packs",
         }
     }
 
-    /// The folder beside `options.txt` the file goes in; a modpack is imported and a mod
-    /// ported instead.
+    /// The folder beside `options.txt` the file goes in; a modpack is imported, a mod ported
+    /// and a data pack put in a world instead.
     pub fn folder(self) -> Option<&'static str> {
         match self {
             Kind::ResourcePack => Some("resourcepacks"),
             Kind::Shader => Some("shaderpacks"),
-            Kind::Modpack | Kind::Mod => None,
+            Kind::Modpack | Kind::Mod | Kind::DataPack => None,
         }
     }
 }
@@ -132,6 +142,19 @@ impl Project {
     pub fn support(&self) -> Support {
         support(self.kind, &self.game_versions, &self.loaders)
     }
+
+    /// The project as a data pack, for a search of data packs or an install into a world;
+    /// its page is Modrinth's data pack page.
+    pub fn as_datapack(self) -> Project {
+        Project {
+            page: match self.source {
+                SourceId::Modrinth => format!("https://modrinth.com/datapack/{}", self.slug),
+                _ => self.page,
+            },
+            kind: Kind::DataPack,
+            ..self
+        }
+    }
 }
 
 /// One downloadable file of a version, with the checksums its source publishes.
@@ -286,6 +309,14 @@ pub fn support(kind: Kind, game_versions: &[String], loaders: &[String]) -> Supp
             Support::Partial("Horizon runs the mods it can port, from your own downloads.".into())
         }
         Kind::Shader => Support::No("Not one of Horizon's own shader packs.".into()),
+        Kind::DataPack => {
+            let made_for = match newest_release(game_versions) {
+                _ if game_versions.iter().any(|v| v == GAME) => String::new(),
+                Some(newest) => format!("Made for {newest}: the game may refuse it. "),
+                None => "Lists no Minecraft version. ".into(),
+            };
+            Support::Partial(format!("{made_for}{DATAPACK_SUPPORT}"))
+        }
         Kind::Mod => {
             if !loaders.iter().any(|l| java::LOADERS.contains(&l.as_str())) {
                 Support::No("Not a Fabric, NeoForge or Forge mod.".into())
@@ -303,6 +334,12 @@ pub fn support(kind: Kind, game_versions: &[String], loaders: &[String]) -> Supp
     }
 }
 
+/// What a data pack does in Horizon today, said before install; the install says it for the
+/// pack's own files (`crate::datapacks::coverage`).
+pub const DATAPACK_SUPPORT: &str = "Horizon runs a data pack's functions, function tags, \
+     predicates and item modifiers; not yet its recipes, loot tables, advancements, other tags \
+     or worldgen.";
+
 /// A Minecraft version whose mods port-pack carries over: 1.21 and later (the data folders
 /// took their current names in 1.21).
 pub fn portable_version(v: &str) -> bool {
@@ -356,6 +393,15 @@ pub fn pick(kind: Kind, versions: &[Version], everything: bool) -> Option<&Versi
             .find(made_for)
             .or_else(|| usable.filter(java).find(|v| everything && ported(v)));
     }
+    if kind == Kind::DataPack {
+        // Most data packs on Modrinth ship a mod build too: only the data pack files.
+        let mut packs = usable.filter(|v| v.loaders.iter().any(|l| l == "datapack"));
+        let made_for = |v: &&Version| v.game_versions.iter().any(|g| g == GAME);
+        return packs
+            .clone()
+            .find(made_for)
+            .or_else(|| packs.find(|_| everything));
+    }
     let runs = |v: &&Version| match support(kind, &v.game_versions, &v.loaders) {
         Support::Works => true,
         // A modpack's version is for its own Minecraft.
diff --git a/launcher/src/browser/curseforge.rs b/launcher/src/browser/curseforge.rs
index 56d73777a..68002c5ed 100644
--- a/launcher/src/browser/curseforge.rs
+++ b/launcher/src/browser/curseforge.rs
@@ -25,6 +25,7 @@ fn class(kind: Kind) -> u64 {
         Kind::Modpack => 4471,
         Kind::Mod => 6,
         Kind::Shader => 6552,
+        Kind::DataPack => 6945,
     }
 }
 
diff --git a/launcher/src/browser/horizon.rs b/launcher/src/browser/horizon.rs
index 741fe336a..7357efc22 100644
--- a/launcher/src/browser/horizon.rs
+++ b/launcher/src/browser/horizon.rs
@@ -484,6 +484,7 @@ fn relative(kind: Kind, id: &str, file_name: &str) -> Result<String, String> {
         Kind::ResourcePack => Ok(format!("resourcepacks/{file_name}")),
         Kind::Shader => Ok(format!("shaderpacks/{file_name}")),
         Kind::Modpack => Err("A modpack installs as its own profile (pack::install).".into()),
+        Kind::DataPack => Err("Horizon's registry has no data packs.".into()),
     }
 }
 
diff --git a/launcher/src/browser/horizon/pack.rs b/launcher/src/browser/horizon/pack.rs
index 95235a505..2b8e2db9e 100644
--- a/launcher/src/browser/horizon/pack.rs
+++ b/launcher/src/browser/horizon/pack.rs
@@ -37,7 +37,7 @@ pub fn list() -> Vec<Installed> {
     list_in(&packs_dir())
 }
 
-fn list_in(dir: &Path) -> Vec<Installed> {
+pub(crate) fn list_in(dir: &Path) -> Vec<Installed> {
     let mut packs: Vec<Installed> = fs::read_dir(dir)
         .into_iter()
         .flatten()
diff --git a/launcher/src/browser/installed.rs b/launcher/src/browser/installed.rs
index c866dd26d..c6dcfb41f 100644
--- a/launcher/src/browser/installed.rs
+++ b/launcher/src/browser/installed.rs
@@ -296,5 +296,67 @@ pub fn fetch_modpack(
     source.fetch(file, folder, progress)
 }
 
+/// A data pack installed into a world.
+pub struct DataPackInstall {
+    pub pack: crate::datapacks::DataPack,
+    /// Its version's number.
+    pub number: String,
+    /// What of it runs in Horizon.
+    pub coverage: crate::datapacks::Coverage,
+}
+
+/// Downloads a project's data pack (checksum checked) into the world folder `world`, under a
+/// free name. Refused when nothing in it runs in Horizon yet. It isn't recorded with the
+/// browser's installs: the world's data pack list (Home, `worlds datapack-list`) has it.
+pub fn install_datapack(
+    source: &dyn Source,
+    project: &Project,
+    everything: bool,
+    world: &Path,
+    progress: &dyn Fn(f32),
+) -> Result<DataPackInstall, String> {
+    if project.kind != Kind::DataPack && !project.loaders.iter().any(|l| l == "datapack") {
+        return Err(format!("{} isn't a data pack.", project.title));
+    }
+    let versions = source.versions(project)?;
+    let version = pick(Kind::DataPack, &versions, everything).ok_or_else(|| {
+        format!(
+            "{} has no data pack for {}{}.",
+            project.title,
+            super::GAME,
+            if everything {
+                " or any other version"
+            } else {
+                ""
+            }
+        )
+    })?;
+    let file = version.file().expect("pick keeps versions with a file");
+    let folder = std::env::temp_dir().join(format!(
+        "horizon-launcher-datapack-{}-{}",
+        std::process::id(),
+        version.id
+    ));
+    let result = source.fetch(file, &folder, progress).and_then(|zip| {
+        let coverage = crate::datapacks::coverage(&zip)?;
+        if coverage.read.is_empty() {
+            return Err(format!(
+                "{} would change nothing in Horizon yet: it has no functions, predicates or item \
+                 modifiers, and Horizon doesn't read its {} yet.",
+                project.title,
+                coverage.not_read()
+            ));
+        }
+        let pack = crate::datapacks::add(world, &zip)?;
+        Ok(DataPackInstall {
+            pack,
+            number: version.number.clone(),
+            coverage,
+        })
+    });
+    let _ = fs::remove_dir_all(&folder);
+    result
+}
+
 #[cfg(test)]
 mod tests;
diff --git a/launcher/src/browser/installed/tests.rs b/launcher/src/browser/installed/tests.rs
index cb2814c29..152ff03c3 100644
--- a/launcher/src/browser/installed/tests.rs
+++ b/launcher/src/browser/installed/tests.rs
@@ -340,3 +340,91 @@ fn shader_packs_older_launchers_installed_are_left_alone() {
     assert!(home.join("shaderpacks/old-pack.zip").is_file());
     fs::remove_dir_all(&home).unwrap();
 }
+
+/// A data pack zip with these files.
+fn datapack_zip(files: &[&str]) -> Vec<u8> {
+    use std::io::Write;
+    let mut zip = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+    let options = zip::write::SimpleFileOptions::default();
+    zip.start_file("pack.mcmeta", options).unwrap();
+    zip.write_all(br#"{"pack":{"pack_format":94,"description":"Test"}}"#)
+        .unwrap();
+    for name in files {
+        zip.start_file(*name, options).unwrap();
+        zip.write_all(b"{}").unwrap();
+    }
+    zip.finish().unwrap().into_inner()
+}
+
+#[test]
+fn data_packs_go_into_a_world_when_something_in_them_runs() {
+    let world = home("datapack").join("saves/New World");
+    fs::create_dir_all(&world).unwrap();
+    let mut fake = Fake::default();
+    let mut tools = project("tools", Kind::DataPack);
+    tools.loaders = vec!["datapack".into()];
+    fake.add(tools);
+    let mut terrain = project("terrain", Kind::Mod);
+    terrain.loaders = vec!["datapack".into(), "fabric".into()];
+    fake.add(terrain);
+    let mut jar = project("jar", Kind::Mod);
+    jar.loaders = vec!["fabric".into()];
+    fake.add(jar);
+    let runs = datapack_zip(&[
+        "data/t/function/a.mcfunction",
+        "data/t/function/b.mcfunction",
+        "data/minecraft/tags/function/load.json",
+        "data/t/recipe/r.json",
+    ]);
+    fake.release("tools", "2.0", &[], &runs, false);
+    fake.release(
+        "terrain",
+        "1.0",
+        &[],
+        &datapack_zip(&["data/t/worldgen/biome/b.json"]),
+        false,
+    );
+    let tools = fake.project("tools").unwrap();
+    let off = &|_: f32| {};
+
+    let done = install_datapack(&fake, &tools, false, &world, off).unwrap();
+    assert_eq!(done.pack.file, "tools-2.0.zip");
+    assert!(done.pack.enabled);
+    assert_eq!(done.number, "2.0");
+    assert_eq!(
+        done.coverage.summary(),
+        "Runs its 2 functions, 1 function tag. Not read yet: 1 recipe."
+    );
+    assert!(world.join("datapacks/tools-2.0.zip").is_file());
+    // Nothing of it in the browser's own list.
+    assert!(Installed::load(world.parent().unwrap().parent().unwrap())
+        .entries
+        .is_empty());
+    let again = install_datapack(&fake, &tools, false, &world, off).unwrap();
+    assert_eq!(again.pack.file, "tools-2.0 (2).zip");
+
+    let terrain = fake.project("terrain").unwrap();
+    let refused = install_datapack(&fake, &terrain, false, &world, off)
+        .err()
+        .unwrap();
+    assert_eq!(
+        refused,
+        "Pack terrain would change nothing in Horizon yet: it has no functions, predicates or \
+         item modifiers, and Horizon doesn't read its 1 worldgen yet."
+    );
+    let jar = fake.project("jar").unwrap();
+    assert!(install_datapack(&fake, &jar, false, &world, off).is_err());
+
+    let mut bad = project("bad", Kind::DataPack);
+    bad.loaders = vec!["datapack".into()];
+    fake.add(bad);
+    fake.release("bad", "1", &[], &runs, true);
+    let bad = fake.project("bad").unwrap();
+    assert!(install_datapack(&fake, &bad, false, &world, off).is_err());
+    let names: Vec<String> = fs::read_dir(world.join("datapacks"))
+        .unwrap()
+        .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
+        .collect();
+    assert_eq!(names.len(), 2, "{names:?}");
+    fs::remove_dir_all(world.parent().unwrap().parent().unwrap()).unwrap();
+}
diff --git a/launcher/src/browser/modrinth.rs b/launcher/src/browser/modrinth.rs
index fb71d0391..d62e2a26d 100644
--- a/launcher/src/browser/modrinth.rs
+++ b/launcher/src/browser/modrinth.rs
@@ -14,14 +14,17 @@ fn project_type(kind: Kind) -> &'static str {
         Kind::Modpack => "modpack",
         Kind::Mod => "mod",
         Kind::Shader => "shader",
+        Kind::DataPack => "datapack",
     }
 }
 
-/// The kind of a Modrinth project; its shader packs (the shaders/ format) are not offered.
+/// The kind of a Modrinth project; its shader packs (the shaders/ format) are not offered. A
+/// data pack says it is a `mod` (most also ship a mod build): the search for data packs marks
+/// its hits, and an install into a world asks for its data pack files.
 fn kind_of(project_type: &str) -> Option<Kind> {
     Kind::ALL
         .into_iter()
-        .filter(|k| *k != Kind::Shader)
+        .filter(|k| !matches!(k, Kind::Shader | Kind::DataPack))
         .find(|k| self::project_type(*k) == project_type)
 }
 
@@ -31,7 +34,9 @@ pub(super) fn facets(query: &Query) -> String {
     let mut all = vec![vec![format!("project_type:{}", project_type(query.kind))]];
     match &f.game_version {
         Some(v) => all.push(vec![format!("versions:{v}")]),
-        None if !query.everything && matches!(query.kind, Kind::ResourcePack | Kind::Mod) => {
+        None if !query.everything
+            && matches!(query.kind, Kind::ResourcePack | Kind::Mod | Kind::DataPack) =>
+        {
             all.push(vec![format!("versions:{GAME}")])
         }
         None => {}
@@ -167,6 +172,14 @@ pub(super) fn parse_version(v: &Value) -> Option<Version> {
     })
 }
 
+/// The files of one version (`GET /version/{id}`), with their downloads and checksums.
+pub fn version_files(version: &str) -> Result<Vec<FileRef>, String> {
+    let v = get(&format!("{API}/version/{}", encode(version)))?;
+    parse_version(&v)
+        .map(|v| v.files)
+        .ok_or_else(|| format!("Modrinth: no version {version}."))
+}
+
 impl Source for Modrinth {
     fn id(&self) -> SourceId {
         SourceId::Modrinth
@@ -182,6 +195,10 @@ impl Source for Modrinth {
             .into_iter()
             .flatten()
             .filter_map(parse_hit)
+            .map(|p| match query.kind {
+                Kind::DataPack => p.as_datapack(),
+                _ => p,
+            })
             .collect())
     }
 
@@ -222,7 +239,15 @@ impl Source for Modrinth {
             ));
         }
         let (c, l, v) = cached.as_ref().expect("filled above");
-        Ok(details::modrinth_tags(project_type(kind), c, l, v))
+        // Data packs share the mods' categories; their one loader is `datapack`.
+        let mut tags = match kind {
+            Kind::DataPack => details::modrinth_tags("mod", c, l, v),
+            _ => details::modrinth_tags(project_type(kind), c, l, v),
+        };
+        if kind == Kind::DataPack {
+            tags.loaders.clear();
+        }
+        Ok(tags)
     }
 }
 
diff --git a/launcher/src/browser/tests.rs b/launcher/src/browser/tests.rs
index 50bfbae40..eb22be38a 100644
--- a/launcher/src/browser/tests.rs
+++ b/launcher/src/browser/tests.rs
@@ -72,6 +72,51 @@ fn picks_the_newest_version_that_runs() {
     assert!(pick(Kind::ResourcePack, &[blocked, empty], true).is_none());
 }
 
+#[test]
+fn data_packs_are_their_own_kind() {
+    // Most data packs on Modrinth also ship a mod build; only the data pack files are picked.
+    let versions = [
+        version("fabric", &[GAME], &["fabric", "neoforge"]),
+        version("pack", &[GAME], &["datapack"]),
+        version("old", &["1.21.4"], &["datapack"]),
+    ];
+    assert_eq!(pick(Kind::DataPack, &versions, false).unwrap().id, "pack");
+    assert!(pick(Kind::DataPack, &versions[2..], false).is_none());
+    assert_eq!(
+        pick(Kind::DataPack, &versions[2..], true).unwrap().id,
+        "old"
+    );
+    assert!(pick(Kind::DataPack, &versions[..1], true).is_none());
+
+    let now = support(Kind::DataPack, &v(&[GAME]), &v(&["datapack"]));
+    assert_eq!(now.reason(), Some(DATAPACK_SUPPORT));
+    let old = support(Kind::DataPack, &v(&["1.21.4"]), &v(&["datapack"]));
+    assert!(
+        old.reason().unwrap().starts_with("Made for 1.21.4"),
+        "{old:?}"
+    );
+    assert!(old.installable());
+
+    assert_eq!(
+        modrinth::facets(&Query::new("", Kind::DataPack)),
+        r#"[["project_type:datapack"],["versions:26.3"]]"#
+    );
+    // A data pack's hit says `mod`: the search for data packs marks it.
+    let hit = serde_json::json!({
+        "project_id": "bVrj3hwG", "project_type": "mod", "slug": "terralith",
+        "title": "Terralith", "categories": ["datapack", "fabric", "worldgen"],
+        "versions": [GAME],
+    });
+    let p = modrinth::parse_hit(&hit).unwrap();
+    assert_eq!(p.kind, Kind::Mod);
+    let p = p.as_datapack();
+    assert_eq!(
+        (p.kind, p.page.as_str()),
+        (Kind::DataPack, "https://modrinth.com/datapack/terralith")
+    );
+    assert_eq!(Kind::DataPack.folder(), None);
+}
+
 #[test]
 fn file_names_must_be_plain() {
     for good in [
diff --git a/launcher/src/cli.rs b/launcher/src/cli.rs
index 7d6ff7514..cf7770c65 100644
--- a/launcher/src/cli.rs
+++ b/launcher/src/cli.rs
@@ -3,6 +3,8 @@
 use clap::{Parser, Subcommand};
 use horizon_launcher::account::{self, Accounts};
 use horizon_launcher::backend::{self, Release};
+use horizon_launcher::instances;
+use horizon_launcher::server_list;
 use std::io::{IsTerminal, Write};
 use std::path::PathBuf;
 use std::process::Command;
@@ -84,10 +86,32 @@ enum AccountCmd {
         /// Its name or UUID
         who: String,
     },
-    /// Play as this account
+    /// Play as this account, or as one of your offline names
     Select { who: String },
-    /// Play offline, without an account
-    Offline,
+    /// Play offline, without an account: as NAME (kept to switch back to; 3 to 16 letters,
+    /// digits or _), or as the name the game made up
+    Offline { name: Option<String> },
+    /// Forget one of your offline names
+    ForgetOffline { name: String },
+    /// Show or set an offline name's skin and cape: a 64x64 (or 64x32) skin PNG, a 64x32 cape
+    /// PNG, the model. Kept by the launcher and given to the game when that name plays
+    Skin {
+        name: String,
+        /// The skin's PNG
+        file: Option<PathBuf>,
+        /// classic or slim arms
+        #[arg(long)]
+        model: Option<String>,
+        /// The cape's PNG
+        #[arg(long)]
+        cape: Option<PathBuf>,
+        /// Back to the default skin
+        #[arg(long)]
+        no_skin: bool,
+        /// Take the cape off
+        #[arg(long)]
+        no_cape: bool,
+    },
 }
 
 #[derive(Subcommand)]
@@ -156,9 +180,257 @@ enum ModpackCmd {
 }
 
 #[derive(Subcommand)]
-enum ModsCmd {
-    /// What the browser installed (the default)
+enum InstanceCmd {
+    /// The instances, each with its game folder (* = the one Play starts)
     List,
+    /// Make an instance: empty but for your options and name, or a copy of another one's
+    /// worlds, options and packs
+    Create {
+        name: String,
+        /// The instance to copy (its name or id)
+        #[arg(long)]
+        copy: Option<String>,
+    },
+    /// Rename an instance (its folder stays)
+    Rename { instance: String, name: String },
+    /// Set an instance's icon: a block or item name from your prepared files (grass_block),
+    /// a colour (#3fa7d6), or none
+    Icon { instance: String, icon: String },
+    /// Put an instance in a sidebar group, or take it out with no group
+    Group {
+        instance: String,
+        group: Option<String>,
+    },
+    /// Make Play start this instance
+    Select { instance: String },
+    /// Keep an instance on one installed Horizon version, or "latest" to follow updates again
+    Version { instance: String, version: String },
+    /// Export an instance (or a port) to share: its settings, packs, Horizon mods and the worlds
+    /// named, as a .mrpack (resource packs from Modrinth listed by download) or a zip. Never
+    /// logs, screenshots or account data; worlds go without their per-player files
+    Export {
+        /// The instance (default: the selected one)
+        instance: Option<String>,
+        #[arg(long, value_enum, default_value_t = ExportFormat::Mrpack)]
+        format: ExportFormat,
+        /// A world to put in it (its name or folder); repeat for more
+        #[arg(long)]
+        world: Vec<String>,
+        /// Where to write it (default: "<name>.mrpack" in the current folder)
+        #[arg(long)]
+        out: Option<PathBuf>,
+    },
+    /// Show or set what runs around an instance's game: a shell command before it (the game
+    /// starts only if it succeeds), a wrapper it runs through (`nice -n 5`), and environment
+    /// variables ("NAME=value NAME2=value"). An empty value clears one. On Linux, also GameMode,
+    /// MangoHud and the dedicated graphics card, when the computer has them
+    Launch {
+        instance: String,
+        #[arg(long)]
+        pre_launch: Option<String>,
+        #[arg(long)]
+        wrapper: Option<String>,
+        #[arg(long)]
+        env: Option<String>,
+        /// Linux: run it through GameMode (gamemoderun), on or off
+        #[arg(long)]
+        gamemode: Option<String>,
+        /// Linux: MangoHud's overlay, on or off
+        #[arg(long)]
+        mangohud: Option<String>,
+        /// Linux: the dedicated graphics card (DRI_PRIME, or NVIDIA's offload), on or off
+        #[arg(long)]
+        dedicated_gpu: Option<String>,
+    },
+    /// Put a shortcut on the desktop that plays an instance (`play --instance`): a .desktop
+    /// file (also in the applications menu) on Linux, an app on macOS, a .lnk on Windows
+    Shortcut {
+        /// The instance (default: the selected one)
+        instance: Option<String>,
+        /// Move the instance's shortcuts to the trash instead
+        #[arg(long)]
+        remove: bool,
+    },
+    /// Import what a file is, as dropping it on the window does: a shared instance (a .mrpack
+    /// without mod loaders, such as `instance export` writes, or a game folder zip) becomes a
+    /// new instance; a Java modpack goes to the Modpacks import; a resource or shader pack into
+    /// the instance (default: the selected one)
+    Import {
+        file: PathBuf,
+        /// The instance a pack goes into
+        #[arg(long)]
+        instance: Option<String>,
+    },
+}
+
+#[derive(Clone, Copy, clap::ValueEnum)]
+enum ExportFormat {
+    /// Modrinth's modpack format
+    Mrpack,
+    /// The game folder's layout, zipped
+    Zip,
+}
+
+#[derive(Subcommand)]
+enum WorldsCmd {
+    /// The worlds: name, mode, version, last played and size (the default)
+    List {
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Zip a world into the instance's backups/ folder, as the game's Make Backup does
+    Backup {
+        /// Its folder or name
+        world: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Copy a world beside it, as "<name> (1)"
+    Copy {
+        world: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Move a world to the system's trash
+    Delete {
+        world: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// A world's data packs, and which are on
+    DatapackList {
+        world: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Copy a data pack zip into a world (the game turns it on when the world opens)
+    DatapackAdd {
+        world: String,
+        file: PathBuf,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Move a world's data pack to the system's trash
+    DatapackRemove {
+        world: String,
+        /// Its file name, with or without .zip
+        pack: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+}
+
+#[derive(Clone, Copy, clap::ValueEnum)]
+enum PackKindArg {
+    Resource,
+    Shader,
+}
+
+impl From<PackKindArg> for horizon_launcher::packs::Kind {
+    fn from(k: PackKindArg) -> Self {
+        match k {
+            PackKindArg::Resource => Self::Resource,
+            PackKindArg::Shader => Self::Shader,
+        }
+    }
+}
+
+#[derive(Subcommand)]
+enum PacksCmd {
+    /// The resource and shader packs, and which are on (the default)
+    List {
+        /// Only this kind
+        #[arg(long, value_enum)]
+        kind: Option<PackKindArg>,
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Copy a pack file in: a resource pack .zip, a shader pack .zip or a .hshader
+    Add {
+        file: PathBuf,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Turn a pack on (a resource pack goes on top; a shader pack replaces the one that was on)
+    On {
+        /// Its file name or title
+        pack: String,
+        #[arg(long, value_enum, default_value_t = PackKindArg::Resource)]
+        kind: PackKindArg,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Turn a pack off
+    Off {
+        pack: String,
+        #[arg(long, value_enum, default_value_t = PackKindArg::Resource)]
+        kind: PackKindArg,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Turn a pack off and move it to the system's trash
+    Remove {
+        pack: String,
+        #[arg(long, value_enum, default_value_t = PackKindArg::Resource)]
+        kind: PackKindArg,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+}
+
+#[derive(Subcommand)]
+enum ScreenshotsCmd {
+    /// The screenshots, the newest first, with their files (the default)
+    List {
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Move a screenshot to the system's trash
+    Delete {
+        /// Its file name, with or without .png
+        screenshot: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+}
+
+#[derive(Subcommand)]
+enum MultiplayerCmd {
+    /// The servers of the game's Multiplayer screen (the default)
+    List {
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Add a server to the list
+    Add {
+        /// Its address, as in the game's Add Server (host or host:port)
+        address: String,
+        /// Its name in the list (default: Minecraft Server)
+        #[arg(long)]
+        name: Option<String>,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Remove a server from the list: its position from 1, name or address
+    Remove {
+        server: String,
+        #[arg(long)]
+        instance: Option<String>,
+    },
+}
+
+#[derive(Subcommand)]
+enum ModsCmd {
+    /// What the browser installed in an instance (the default)
+    List {
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
     /// Search for packs Horizon loads
     Search {
         text: Vec<String>,
@@ -180,10 +452,17 @@ enum ModsCmd {
         #[arg(long, value_enum, default_value_t = SourceArg::Modrinth)]
         source: SourceArg,
     },
-    /// Install a pack and what it needs, by its id or slug (checksums checked); a Java mod is
-    /// ported into horizon-mods and turned on; a modpack is imported
+    /// Install a pack and what it needs into an instance, by its id or slug (checksums
+    /// checked); a Java mod is ported into horizon-mods and turned on; a modpack is imported as
+    /// an instance of its own; a data pack goes into the world `--world` names
     Install {
         project: String,
+        /// Install the project's data pack into this world of the instance (its name or folder)
+        #[arg(long)]
+        world: Option<String>,
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
         /// Allow a version made for another Minecraft version
         #[arg(long)]
         everything: bool,
@@ -196,13 +475,31 @@ enum ModsCmd {
         /// Only say what is newer
         #[arg(long)]
         check: bool,
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
     },
     /// Remove a pack the browser installed
-    Remove { project: String },
+    Remove {
+        project: String,
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
     /// Turn on a mod the browser installed (horizon-mods.txt, as the game's Options > Mods does)
-    Enable { project: String },
+    Enable {
+        project: String,
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
     /// Turn off a mod the browser installed; it stays installed
-    Disable { project: String },
+    Disable {
+        project: String,
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
 }
 
 #[derive(Clone, Copy, clap::ValueEnum)]
@@ -212,6 +509,8 @@ enum KindArg {
     Modpack,
     /// Horizon's own shader packs (Horizon's registry only)
     Shader,
+    /// Data packs (Modrinth): install one into a world with `mods install <pack> --world <name>`
+    Datapack,
 }
 
 #[derive(Clone, Copy, clap::ValueEnum)]
@@ -261,6 +560,9 @@ enum Cmd {
     Play {
         #[arg(long)]
         version: Option<String>,
+        /// The instance to play (its name or id; default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
         /// Open or create this world (a folder under saves) at once
         #[arg(long)]
         world: Option<String>,
@@ -270,6 +572,9 @@ enum Cmd {
         /// Join a friend's world with its invite code
         #[arg(long)]
         join: Option<String>,
+        /// Join this server at once: an address, or a server of the list by name or position
+        #[arg(long, conflicts_with_all = ["world", "join"])]
+        server: Option<String>,
         /// An extra argument for the game, passed through as-is (repeatable), for example
         /// --server-thread
         #[arg(long = "arg", value_name = "ARG", allow_hyphen_values = true)]
@@ -297,7 +602,11 @@ enum Cmd {
     },
     /// Show the launcher's settings, or set one (the Settings page): selected-version TAG,
     /// minecraft-dir PATH, server-dir PATH ("default" resets a folder), install-new-versions
-    /// on|off, opening-animation on|off, proxy http://host:port ("default" removes it)
+    /// on|off, opening-animation on|off, proxy http://host:port ("default" removes it),
+    /// while-playing stay|minimize|hide (what the window does while the game runs), language
+    /// system|en|fr|ru (the window's language; system follows the computer's), accent
+    /// violet|blue|teal|green|amber|red|pink, background PATH (a picture behind Home; "default"
+    /// shows Horizon's landscape)
     Settings {
         #[arg(value_parser = SETTING_KEYS)]
         key: Option<String>,
@@ -312,6 +621,16 @@ enum Cmd {
         #[arg(allow_hyphen_values = true)]
         args: Option<String>,
     },
+    /// Upload an instance's latest.log to mclo.gs (a paste service for Minecraft logs) and print
+    /// its link, for a bug report: only when the player asks. The home folder, the user name and
+    /// the account names are taken out first; the link expires after 90 days unread
+    ShareLog {
+        /// The instance (default: the selected one)
+        #[arg(long)]
+        instance: Option<String>,
+    },
+    /// Delete a log shared with share-log: the "<id>:<token>" it printed
+    UnshareLog { shared: String },
     /// Print the end of the game's log (logs/latest.log in the game folder), or its newest crash
     /// report
     Logs {
@@ -341,6 +660,31 @@ enum Cmd {
         #[command(subcommand)]
         action: Option<DataCmd>,
     },
+    /// Instances: separate game folders, each with its own worlds, options and packs
+    Instance {
+        #[command(subcommand)]
+        action: Option<InstanceCmd>,
+    },
+    /// An instance's single-player worlds: list them, back one up, copy or delete it
+    Worlds {
+        #[command(subcommand)]
+        action: Option<WorldsCmd>,
+    },
+    /// An instance's resource and shader packs: list, add, turn on or off, remove
+    Packs {
+        #[command(subcommand)]
+        action: Option<PacksCmd>,
+    },
+    /// The screenshots F2 took in an instance: list, delete
+    Screenshots {
+        #[command(subcommand)]
+        action: Option<ScreenshotsCmd>,
+    },
+    /// The servers in an instance's Multiplayer list (servers.dat): list, add, remove
+    Multiplayer {
+        #[command(subcommand)]
+        action: Option<MultiplayerCmd>,
+    },
     /// Modpacks: import a Java pack, see its coverage report, port what this computer can and
     /// play it as its own profile (docs/modpacks.md)
     Modpack {
@@ -399,13 +743,17 @@ pub fn command() -> clap::Command {
 pub const AI_COMMANDS: [&str; 2] = ["mcp", "agent-config"];
 
 /// The keys `settings` sets.
-const SETTING_KEYS: [&str; 6] = [
+const SETTING_KEYS: [&str; 10] = [
     "selected-version",
     "minecraft-dir",
     "server-dir",
     "install-new-versions",
     "opening-animation",
     "proxy",
+    "while-playing",
+    "language",
+    "accent",
+    "background",
 ];
 
 fn on_off(value: &str) -> Result<bool, String> {
@@ -424,6 +772,36 @@ fn set_setting(s: &mut backend::Settings, key: &str, value: &str) -> Result<(),
         "server-dir" => s.server_dir = folder(value),
         "install-new-versions" => s.install_new_versions = Some(on_off(value)?),
         "opening-animation" => s.skip_opening = !on_off(value)?,
+        "while-playing" => {
+            s.while_playing = backend::WhilePlaying::parse(value)
+                .ok_or_else(|| format!("{value}: say stay, minimize or hide"))?
+        }
+        "accent" => {
+            use horizon_launcher::themes::Accent;
+            s.accent = Accent::parse(value).ok_or_else(|| {
+                let names: Vec<_> = Accent::ALL.iter().map(|a| a.name()).collect();
+                format!("{value}: say {}", names.join(", "))
+            })?
+        }
+        "background" => {
+            s.background = match value.trim() {
+                "default" | "" => None,
+                file => Some(horizon_launcher::themes::keep_background(
+                    &backend::data_dir(),
+                    std::path::Path::new(file),
+                )?),
+            }
+        }
+        "language" => {
+            use horizon_launcher::i18n::Language;
+            s.language = match value.trim() {
+                "system" | "default" => None,
+                code => Some(
+                    Language::parse(code)
+                        .ok_or_else(|| format!("{value}: say system, en, fr or ru"))?,
+                ),
+            }
+        }
         "proxy" => {
             if value == "default" || value.is_empty() {
                 s.proxy = None;
@@ -449,6 +827,10 @@ fn settings_json(s: &backend::Settings) -> serde_json::Value {
         "game_args": s.game_args,
         "proxy": s.proxy,
         "desktop_entry": s.desktop_entry.unwrap_or(true),
+        "while_playing": s.while_playing.name(),
+        "language": s.language.map_or("system", |l| l.code()),
+        "accent": s.accent.name(),
+        "background": horizon_launcher::themes::background(&backend::data_dir(), s.background.as_deref()),
         "no_ai": backend::no_ai(),
     })
 }
@@ -606,23 +988,45 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
         }
         Cmd::Play {
             version,
+            instance,
             world,
             creative,
             join,
+            server,
             arg,
         } => {
-            let mut cmd = backend::client(&backend::resolve_version(version.as_deref())?)?;
+            let instance = match instance {
+                Some(name) => instances::find(&name)?,
+                None => instances::selected(),
+            };
+            let mut cmd = backend::client(&instance.resolve_version(version.as_deref())?)?;
+            instances::apply(&mut cmd, &instance)?;
             if let Some(code) = join {
                 backend::join_friend(&mut cmd, &code)?;
             }
             if let Some(world) = world {
                 cmd.arg("--world").arg(world);
             }
+            if let Some(server) = server {
+                let list = server_list::List::load(&instance.home);
+                let ip = server_list::find(&list, &server).map_or(server, |(_, s)| s.ip);
+                cmd.arg("--server").arg(ip);
+            }
             if creative {
                 cmd.arg("--creative");
             }
             cmd.args(arg);
-            attached(cmd)?
+            let started = std::time::Instant::now();
+            let accounts = Accounts::load();
+            if let Some(name) = accounts.name_arg() {
+                cmd.arg("--name").arg(name);
+            }
+            cmd.envs(accounts.look_env());
+            let played = attached(horizon_launcher::launch::wrap(cmd, &instance.launch));
+            if let Err(e) = instances::record_play(&instance.id, started.elapsed()) {
+                eprintln!("Play time not saved: {e}");
+            }
+            played?
         }
         Cmd::Server {
             dir,
@@ -762,6 +1166,41 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
                 println!("Game arguments: {line}");
             }
         }
+        Cmd::ShareLog { instance } => {
+            use horizon_launcher::game_log;
+            let i = match instance {
+                Some(name) => instances::find(&name)?,
+                None => instances::selected(),
+            };
+            let path = i.home.join("logs/latest.log");
+            let text =
+                std::fs::read_to_string(&path).map_err(|e| format!("{}: {e}", path.display()))?;
+            let names = game_log::names(&[&i.home, &backend::game_home()]);
+            let text = game_log::private(&text, dirs::home_dir().as_deref(), &names);
+            let shared = game_log::share(&text)?;
+            if as_json {
+                json(serde_json::json!({
+                    "url": shared.url, "delete": format!("{}:{}", shared.id, shared.token),
+                }));
+            } else {
+                println!("{}", shared.url);
+                println!(
+                    "Delete it: horizon-launcher unshare-log {}:{}",
+                    shared.id, shared.token
+                );
+            }
+        }
+        Cmd::UnshareLog { shared } => {
+            let (id, token) = shared
+                .split_once(':')
+                .ok_or("Give the \"<id>:<token>\" share-log printed.")?;
+            horizon_launcher::game_log::unshare(&horizon_launcher::game_log::Shared {
+                url: String::new(),
+                id: id.into(),
+                token: token.into(),
+            })?;
+            println!("Deleted the shared log {id}.");
+        }
         Cmd::Logs { lines, crash } => {
             let (path, text) = backend::read_logs(lines, crash)?;
             if as_json {
@@ -784,8 +1223,28 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
                 println!("Horizon is in the applications menu.");
             }
         }
+        Cmd::Worlds { action } => worlds(
+            action.unwrap_or(WorldsCmd::List { instance: None }),
+            as_json,
+        )?,
+        Cmd::Packs { action } => game_packs(
+            action.unwrap_or(PacksCmd::List {
+                kind: None,
+                instance: None,
+            }),
+            as_json,
+        )?,
+        Cmd::Screenshots { action } => screenshots(
+            action.unwrap_or(ScreenshotsCmd::List { instance: None }),
+            as_json,
+        )?,
+        Cmd::Multiplayer { action } => multiplayer(
+            action.unwrap_or(MultiplayerCmd::List { instance: None }),
+            as_json,
+        )?,
+        Cmd::Instance { action } => instance(action.unwrap_or(InstanceCmd::List), as_json)?,
         Cmd::Modpack { action } => modpack(action.unwrap_or(ModpackCmd::List), as_json)?,
-        Cmd::Mods { action } => mods(action.unwrap_or(ModsCmd::List), as_json)?,
+        Cmd::Mods { action } => mods(action.unwrap_or(ModsCmd::List { instance: None }), as_json)?,
         Cmd::Servers { action } => servers(action.unwrap_or(ServersCmd::List), as_json)?,
         Cmd::Mcp => unreachable!(),
     }
@@ -848,9 +1307,13 @@ fn account_command(action: AccountCmd, as_json: bool) -> Result<(), String> {
                         "name": a.name, "uuid": a.uuid,
                         "selected": accounts.selected.as_ref() == Some(&a.uuid),
                     })).collect::<Vec<_>>(),
+                    "offline": accounts.offline.iter().map(|n| serde_json::json!({
+                        "name": n,
+                        "selected": accounts.player() == account::Player::Offline(n.clone()),
+                    })).collect::<Vec<_>>(),
                     "sign_in_configured": account::client_id().is_some(),
                 }));
-            } else if accounts.accounts.is_empty() {
+            } else if accounts.accounts.is_empty() && accounts.offline.is_empty() {
                 println!("No Microsoft account signed in: the game plays offline.");
             } else {
                 for a in &accounts.accounts {
@@ -861,8 +1324,14 @@ fn account_command(action: AccountCmd, as_json: bool) -> Result<(), String> {
                     };
                     println!("{mark} {}  {}", a.name, a.uuid);
                 }
-                if accounts.selected().is_none() {
-                    println!("Playing offline (`account select NAME` to play as one).");
+                for n in &accounts.offline {
+                    let on = accounts.player() == account::Player::Offline(n.clone());
+                    println!("{} {n}  offline", if on { "*" } else { " " });
+                }
+                if accounts.player() == account::Player::GameName {
+                    println!(
+                        "Playing offline as the game's own name (`account select NAME` to switch)."
+                    );
                 }
             }
         }
@@ -890,15 +1359,94 @@ fn account_command(action: AccountCmd, as_json: bool) -> Result<(), String> {
             println!("Signed out {}.", a.name);
         }
         AccountCmd::Select { who } => {
-            let a = find(&accounts, &who)?;
-            accounts.selected = Some(a.uuid);
+            let offline = accounts
+                .offline
+                .iter()
+                .find(|n| n.eq_ignore_ascii_case(&who))
+                .cloned();
+            let (player, name) = match (accounts.find(&who).cloned(), offline) {
+                (Some(a), _) => (account::Player::Microsoft(a.uuid), a.name),
+                (None, Some(n)) => (
+                    account::Player::Offline(n.clone()),
+                    format!("{n} (offline)"),
+                ),
+                (None, None) => return Err(find(&accounts, &who).unwrap_err()),
+            };
+            accounts.play_as(player)?;
             accounts.save()?;
-            println!("The game plays as {}.", a.name);
+            println!("The game plays as {name}.");
         }
-        AccountCmd::Offline => {
-            accounts.selected = None;
+        AccountCmd::Offline { name } => {
+            let player = match name {
+                Some(n) => account::Player::Offline(n),
+                None => account::Player::GameName,
+            };
+            accounts.play_as(player)?;
             accounts.save()?;
-            println!("The game plays offline.");
+            match accounts.name_arg() {
+                Some(n) => println!("The game plays offline as {n}."),
+                None => println!("The game plays offline, as the name it made up."),
+            }
+        }
+        AccountCmd::Skin {
+            name,
+            file,
+            model,
+            cape,
+            no_skin,
+            no_cape,
+        } => {
+            use horizon_launcher::skins::{self, Model};
+            let name = accounts
+                .offline
+                .iter()
+                .find(|n| n.eq_ignore_ascii_case(&name))
+                .cloned()
+                .ok_or_else(|| {
+                    format!("No offline name {name}: add it with `account offline {name}`.")
+                })?;
+            let model = match model.as_deref() {
+                None => None,
+                Some("classic") => Some(Model::Classic),
+                Some("slim") => Some(Model::Slim),
+                Some(m) => return Err(format!("{m}: say classic or slim")),
+            };
+            let mut look = accounts.look(&name);
+            if let Some(file) = &file {
+                skins::keep(&skins::dir(), &name, file, false)?;
+                look.skin = true;
+            }
+            if let Some(file) = &cape {
+                skins::keep(&skins::dir(), &name, file, true)?;
+                look.cape = true;
+            }
+            if let Some(m) = model {
+                look.model = m;
+            }
+            look.skin &= !no_skin;
+            look.cape &= !no_cape;
+            accounts
+                .looks
+                .insert(name.to_ascii_lowercase(), look.clone());
+            accounts.save()?;
+            if as_json {
+                json(serde_json::json!({
+                    "name": name, "skin": look.skin, "cape": look.cape, "model": look.model.name(),
+                }));
+            } else {
+                let say = |on: bool, what: &str| if on { what.to_string() } else { "none".into() };
+                println!(
+                    "{name}: skin {} ({} arms), cape {}",
+                    say(look.skin, "kept"),
+                    look.model.name(),
+                    say(look.cape, "kept")
+                );
+            }
+        }
+        AccountCmd::ForgetOffline { name } => {
+            accounts.remove_offline(&name)?;
+            accounts.save()?;
+            println!("Forgot the offline name {name}.");
         }
     }
     Ok(())
@@ -1087,7 +1635,20 @@ fn servers(action: ServersCmd, as_json: bool) -> Result<(), String> {
 fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
     use horizon_launcher::browser::{horizon, installed, Kind, Query, SourceId};
     use horizon_launcher::modpacks;
-    let home = backend::game_home();
+    // What the browser installs goes into an instance's game folder; Java mods' checks are kept
+    // in the default one, shared by all.
+    let home = match &action {
+        ModsCmd::List { instance }
+        | ModsCmd::Install { instance, .. }
+        | ModsCmd::Update { instance, .. }
+        | ModsCmd::Remove { instance, .. }
+        | ModsCmd::Enable { instance, .. }
+        | ModsCmd::Disable { instance, .. } => match instance {
+            Some(name) => instances::find(name)?.home,
+            None => instances::selected().home,
+        },
+        ModsCmd::Search { .. } | ModsCmd::Check { .. } => backend::game_home(),
+    };
     let entry_json = |e: &installed::Entry| serde_json::to_value(e).unwrap_or_default();
     let line = |label: &str, f: f32| progress(label.to_string())(f);
     let from_registry = installed::Installed::load(&home)
@@ -1103,7 +1664,7 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
     }
     let on = matches!(action, ModsCmd::Enable { .. });
     match action {
-        ModsCmd::List => {
+        ModsCmd::List { .. } => {
             let list = installed::Installed::load(&home).entries;
             if as_json {
                 json(list.iter().map(entry_json).collect());
@@ -1135,12 +1696,14 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
                 KindArg::Modpack => Kind::Modpack,
                 KindArg::Mod => Kind::Mod,
                 KindArg::Shader => Kind::Shader,
+                KindArg::Datapack => Kind::DataPack,
             };
             let query = Query {
                 everything,
                 ..Query::new(&text.join(" "), kind)
             };
             let found = source.get()?.search(&query)?;
+            let datapack = kind == Kind::DataPack;
             if as_json {
                 json(found.iter().map(|p| {
                     let support = p.support();
@@ -1152,6 +1715,9 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
                     })
                 }).collect());
             } else {
+                if datapack && !found.is_empty() {
+                    println!("{}\n", horizon_launcher::browser::DATAPACK_SUPPORT);
+                }
                 for p in &found {
                     let support = p.support();
                     if p.source == SourceId::Horizon {
@@ -1176,6 +1742,8 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
                     );
                     if unchecked {
                         println!("  horizon-launcher mods check {}", p.slug);
+                    } else if datapack {
+                        println!("  horizon-launcher mods install {} --world <world>", p.slug);
                     } else if let Some(why) = support.reason() {
                         println!("  {why}");
                     }
@@ -1226,9 +1794,44 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
             project,
             everything,
             source,
+            world,
+            ..
         } => {
             let source = source.get()?;
             let p = source.project(&project)?;
+            if let Some(world) = world {
+                let world = horizon_launcher::worlds::find(&home, &world)?;
+                let done = installed::install_datapack(
+                    &*source,
+                    &p,
+                    everything,
+                    &world.path,
+                    &progress(p.title.clone()),
+                )?;
+                if as_json {
+                    json(serde_json::json!({
+                        "world": world.folder, "file": done.pack.file, "version": done.number,
+                        "runs": done.coverage.read, "not_read": done.coverage.unread,
+                    }));
+                } else {
+                    println!(
+                        "{} {} is in {}'s data packs as {}: the game turns it on when the world \
+                         opens. {}",
+                        p.title,
+                        done.number,
+                        world.name,
+                        done.pack.file,
+                        done.coverage.summary()
+                    );
+                }
+                return Ok(());
+            }
+            if p.kind == Kind::DataPack {
+                return Err(format!(
+                    "{} is a data pack: say which world with --world.",
+                    p.title
+                ));
+            }
             if p.kind == Kind::Modpack && p.source == SourceId::Horizon {
                 let pack = horizon::pack::install(&p.id, &line)?;
                 if as_json {
@@ -1271,7 +1874,7 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
                 }
             }
         }
-        ModsCmd::Update { project, check } => {
+        ModsCmd::Update { project, check, .. } => {
             let list = installed::Installed::load(&home).entries;
             let chosen: Vec<_> = list
                 .iter()
@@ -1306,11 +1909,11 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
                 }
             }
         }
-        ModsCmd::Remove { project } => {
+        ModsCmd::Remove { project, .. } => {
             let e = installed::remove(&home, &project)?;
             println!("Removed {} ({}).", e.title, e.file);
         }
-        ModsCmd::Enable { project } | ModsCmd::Disable { project } => {
+        ModsCmd::Enable { project, .. } | ModsCmd::Disable { project, .. } => {
             let e = installed::Installed::load(&home)
                 .lookup(&project)
                 .cloned()
@@ -1337,6 +1940,564 @@ fn mods(action: ModsCmd, as_json: bool) -> Result<(), String> {
     Ok(())
 }
 
+fn instance(action: InstanceCmd, as_json: bool) -> Result<(), String> {
+    use instances::Icon;
+    let value = |i: &instances::Instance, selected: bool| {
+        serde_json::json!({
+            "id": i.id, "name": i.name, "kind": format!("{:?}", i.kind).to_lowercase(),
+            "home": i.home, "icon": i.icon, "group": i.group, "selected": selected,
+            "version": i.version, "played_secs": i.played.as_secs(),
+            "last_played_ms": i.last_played.and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok()).map(|d| d.as_millis() as u64),
+        })
+    };
+    let line = |i: &instances::Instance, selected: bool| {
+        let mark = if selected { "*" } else { " " };
+        let group = i
+            .group
+            .as_ref()
+            .map(|g| format!("  [{g}]"))
+            .unwrap_or_default();
+        let pinned = i
+            .version
+            .as_ref()
+            .map(|v| format!("  {v}"))
+            .unwrap_or_default();
+        let played = match i.last_played {
+            Some(_) => format!("  {} played", instances::play_time(i.played)),
+            None => String::new(),
+        };
+        println!(
+            "{mark} {} ({}){pinned}{group}{played}\n    {}",
+            i.name,
+            i.id,
+            i.home.display()
+        );
+    };
+    let changed = |i: instances::Instance| {
+        let selected = i.id == instances::selected().id;
+        match as_json {
+            true => json(value(&i, selected)),
+            false => line(&i, selected),
+        }
+    };
+    match action {
+        InstanceCmd::List => {
+            let selected = instances::selected().id;
+            let all = instances::list();
+            if as_json {
+                json(all.iter().map(|i| value(i, i.id == selected)).collect());
+            } else {
+                all.iter().for_each(|i| line(i, i.id == selected));
+            }
+        }
+        InstanceCmd::Create { name, copy } => changed(instances::create(&name, copy.as_deref())?),
+        InstanceCmd::Rename { instance, name } => {
+            changed(instances::edit(&instance, |m| m.name = Some(name))?)
+        }
+        InstanceCmd::Icon { instance, icon } => {
+            let icon = (icon != "none").then(|| Icon::parse(&icon)).transpose()?;
+            changed(instances::edit(&instance, |m| m.icon = icon)?)
+        }
+        InstanceCmd::Group { instance, group } => {
+            changed(instances::edit(&instance, |m| m.group = group)?)
+        }
+        InstanceCmd::Select { instance } => changed(instances::select(&instance)?),
+        InstanceCmd::Version { instance, version } => {
+            let pin = match version.as_str() {
+                "latest" => None,
+                tag => Some(backend::resolve_version(Some(tag))?),
+            };
+            changed(instances::edit(&instance, |m| m.version = pin)?)
+        }
+        InstanceCmd::Launch {
+            instance,
+            pre_launch,
+            wrapper,
+            env,
+            gamemode,
+            mangohud,
+            dedicated_gpu,
+        } => {
+            use horizon_launcher::launch;
+            let env = env.as_deref().map(launch::parse_env).transpose()?;
+            let [gamemode, mangohud, dedicated_gpu] =
+                [gamemode, mangohud, dedicated_gpu].map(|v| v.as_deref().map(on_off));
+            let [gamemode, mangohud, dedicated_gpu] = [
+                gamemode.transpose()?,
+                mangohud.transpose()?,
+                dedicated_gpu.transpose()?,
+            ];
+            let found = launch::Found::here();
+            for (on, has, name) in [
+                (gamemode, found.gamemode, "GameMode (gamemoderun)"),
+                (mangohud, found.mangohud, "MangoHud"),
+                (dedicated_gpu, found.two_gpus, "A second graphics card"),
+            ] {
+                if on == Some(true) && !has {
+                    eprintln!(
+                        "{name} isn't on this computer: the switch does nothing until it is."
+                    );
+                }
+            }
+            let changing = pre_launch.is_some()
+                || wrapper.is_some()
+                || env.is_some()
+                || gamemode.is_some()
+                || mangohud.is_some()
+                || dedicated_gpu.is_some();
+            let i = match changing {
+                false => instances::find(&instance)?,
+                true => instances::edit(&instance, |m| {
+                    if let Some(p) = pre_launch {
+                        m.launch.pre_launch = p.trim().to_string();
+                    }
+                    if let Some(w) = wrapper {
+                        m.launch.wrapper = w.trim().to_string();
+                    }
+                    if let Some(e) = env {
+                        m.launch.env = e;
+                    }
+                    if let Some(on) = gamemode {
+                        m.launch.gamemode = on;
+                    }
+                    if let Some(on) = mangohud {
+                        m.launch.mangohud = on;
+                    }
+                    if let Some(on) = dedicated_gpu {
+                        m.launch.dedicated_gpu = on;
+                    }
+                })?,
+            };
+            let l = &i.launch;
+            if as_json {
+                json(serde_json::json!({
+                    "instance": i.id, "pre_launch": l.pre_launch, "wrapper": l.wrapper, "env": l.env,
+                    "gamemode": l.gamemode, "mangohud": l.mangohud, "dedicated_gpu": l.dedicated_gpu,
+                    "found": {
+                        "gamemode": found.gamemode, "mangohud": found.mangohud,
+                        "two_gpus": found.two_gpus, "nvidia": found.nvidia,
+                    },
+                }));
+            } else {
+                println!(
+                    "{}: {}",
+                    i.name,
+                    l.summary().unwrap_or("nothing around the game".into())
+                );
+                println!("  pre-launch: {}", l.pre_launch);
+                println!("  wrapper:    {}", l.wrapper);
+                println!("  env:        {}", launch::env_line(&l.env));
+                let yes = |b: bool| if b { "on" } else { "off" };
+                for (name, on, has) in [
+                    ("gamemode:", l.gamemode, found.gamemode),
+                    ("mangohud:", l.mangohud, found.mangohud),
+                    ("gpu:", l.dedicated_gpu, found.two_gpus),
+                ] {
+                    let note = if has { "" } else { " (not on this computer)" };
+                    println!("  {name:<11} {}{note}", yes(on));
+                }
+            }
+        }
+        InstanceCmd::Shortcut { instance, remove } => {
+            use horizon_launcher::shortcut;
+            let i = match instance {
+                Some(name) => instances::find(&name)?,
+                None => instances::selected(),
+            };
+            let paths = match remove {
+                false => shortcut::make(backend::exe_path(), &i.id, &i.name)?,
+                true => shortcut::remove(&i.id)?,
+            };
+            if as_json {
+                json(serde_json::json!({ "instance": i.id, "paths": paths }));
+            } else if remove && paths.is_empty() {
+                println!("{} has no shortcut.", i.name);
+            } else {
+                let did = if remove { "Moved to the trash" } else { "Made" };
+                for path in paths {
+                    println!("{did}: {}", path.display());
+                }
+            }
+        }
+        InstanceCmd::Import { file, instance } => {
+            use horizon_launcher::import::{self, Dropped};
+            use horizon_launcher::modpacks;
+            match import::what(&file)? {
+                Dropped::Instance => {
+                    let i = import::import_instance(&file, &|line, _| eprintln!("{line}"))?;
+                    if as_json {
+                        json(value(&i, false));
+                    } else {
+                        println!(
+                            "Made the instance {} in {}: horizon-launcher instance select \"{}\"",
+                            i.name,
+                            i.home.display(),
+                            i.name
+                        );
+                    }
+                }
+                Dropped::Modpack => {
+                    let pack = modpacks::import(&file, &|line: String| eprintln!("{line}"))?;
+                    println!("{} ({})", modpacks::outcome(&pack), pack.summary());
+                    println!(
+                        "Port and play it: horizon-launcher modpack port {}",
+                        pack.slug
+                    );
+                }
+                Dropped::Pack(_) => {
+                    let i = match instance {
+                        Some(name) => instances::find(&name)?,
+                        None => instances::selected(),
+                    };
+                    let p = horizon_launcher::packs::add(&i.home, &file)?;
+                    println!(
+                        "Added {} to {}: turn it on with horizon-launcher packs on",
+                        p.title, i.name
+                    );
+                }
+                Dropped::DataPack => {
+                    return Err(format!(
+                        "{} is a data pack: put it into a world with horizon-launcher worlds \
+                         datapack-add <world> <file>",
+                        file.display()
+                    ))
+                }
+            }
+        }
+        InstanceCmd::Export {
+            instance,
+            format,
+            world,
+            out,
+        } => {
+            use horizon_launcher::export::{self, Format};
+            let i = match instance {
+                Some(name) => instances::find(&name)?,
+                None => instances::selected(),
+            };
+            let format = match format {
+                ExportFormat::Mrpack => Format::Mrpack,
+                ExportFormat::Zip => Format::Zip,
+            };
+            let worlds = world
+                .iter()
+                .map(|w| horizon_launcher::worlds::find(&i.home, w).map(|w| w.folder))
+                .collect::<Result<Vec<_>, _>>()?;
+            let linked = match format {
+                Format::Mrpack => export::linkable(&i.home, &export::from_modrinth),
+                Format::Zip => Vec::new(),
+            };
+            let out = match out {
+                Some(out) => out,
+                None => export::free_path(
+                    &std::env::current_dir().map_err(|e| e.to_string())?,
+                    &i.name,
+                    format,
+                ),
+            };
+            let done = export::export(&i.home, &i.name, format, &worlds, &linked, &out)?;
+            if as_json {
+                json(serde_json::json!({
+                    "path": done.path, "copied": done.copied, "linked": done.linked,
+                    "worlds": done.worlds,
+                }));
+            } else {
+                println!(
+                    "Exported {} to {}: {} files, {} listed by their Modrinth download{}.",
+                    i.name,
+                    done.path.display(),
+                    done.copied,
+                    done.linked,
+                    match done.worlds.is_empty() {
+                        true => String::new(),
+                        false => format!(", worlds: {}", done.worlds.join(", ")),
+                    }
+                );
+            }
+        }
+    }
+    Ok(())
+}
+
+fn game_packs(action: PacksCmd, as_json: bool) -> Result<(), String> {
+    use horizon_launcher::packs::{self, Kind};
+    let home = |instance: Option<String>| -> Result<PathBuf, String> {
+        Ok(match instance {
+            Some(name) => instances::find(&name)?.home,
+            None => instances::selected().home,
+        })
+    };
+    let value = |p: &packs::Pack| {
+        serde_json::json!({
+            "kind": format!("{:?}", p.kind).to_lowercase(), "file": p.file, "title": p.title,
+            "description": p.description, "enabled": p.enabled, "path": p.path,
+        })
+    };
+    match action {
+        PacksCmd::List { kind, instance } => {
+            let home = home(instance)?;
+            let kinds = match kind {
+                Some(k) => vec![Kind::from(k)],
+                None => vec![Kind::Resource, Kind::Shader],
+            };
+            let all: Vec<packs::Pack> = kinds.iter().flat_map(|k| packs::list(&home, *k)).collect();
+            if as_json {
+                json(all.iter().map(value).collect());
+            }
+            for k in kinds.iter().filter(|_| !as_json) {
+                println!("{}:", k.folder());
+                let these: Vec<_> = all.iter().filter(|p| p.kind == *k).collect();
+                if these.is_empty() {
+                    println!("    none");
+                }
+                for p in these {
+                    let on = if p.enabled { "on " } else { "off" };
+                    match p.title == p.file {
+                        true => println!("  {on} {}", p.file),
+                        false => println!("  {on} {} ({})", p.title, p.file),
+                    }
+                }
+            }
+        }
+        PacksCmd::Add { file, instance } => {
+            let pack = packs::add(&home(instance)?, &file)?;
+            match as_json {
+                true => json(value(&pack)),
+                false => println!("Added {} to {} (off).", pack.file, pack.kind.folder()),
+            }
+        }
+        PacksCmd::On {
+            pack,
+            kind,
+            instance,
+        } => set_pack(&home(instance)?, kind.into(), &pack, true)?,
+        PacksCmd::Off {
+            pack,
+            kind,
+            instance,
+        } => set_pack(&home(instance)?, kind.into(), &pack, false)?,
+        PacksCmd::Remove {
+            pack,
+            kind,
+            instance,
+        } => {
+            let home = home(instance)?;
+            let p = packs::find(&home, kind.into(), &pack)?;
+            packs::remove(&home, &p)?;
+            println!("{} is in the trash.", p.file);
+        }
+    }
+    Ok(())
+}
+
+fn set_pack(
+    home: &std::path::Path,
+    kind: horizon_launcher::packs::Kind,
+    query: &str,
+    on: bool,
+) -> Result<(), String> {
+    use horizon_launcher::packs;
+    let pack = packs::find(home, kind, query)?;
+    packs::set_enabled(home, &pack, on)?;
+    println!("{} is {}.", pack.title, if on { "on" } else { "off" });
+    Ok(())
+}
+
+fn screenshots(action: ScreenshotsCmd, as_json: bool) -> Result<(), String> {
+    use horizon_launcher::screenshots;
+    let home = |instance: Option<String>| -> Result<PathBuf, String> {
+        Ok(match instance {
+            Some(name) => instances::find(&name)?.home,
+            None => instances::selected().home,
+        })
+    };
+    match action {
+        ScreenshotsCmd::List { instance } => {
+            let home = home(instance)?;
+            let shots = screenshots::list(&home);
+            if as_json {
+                json(
+                    shots
+                        .iter()
+                        .map(|s| {
+                            let millis = s
+                                .taken
+                                .duration_since(std::time::UNIX_EPOCH)
+                                .map_or(0, |d| d.as_millis() as u64);
+                            serde_json::json!({ "name": s.name, "path": s.path, "taken_ms": millis, "size": s.size })
+                        })
+                        .collect(),
+                );
+            } else if shots.is_empty() {
+                println!("No screenshots in {}", screenshots::folder(&home).display());
+            }
+            for s in shots.iter().filter(|_| !as_json) {
+                println!("{}", s.path.display());
+            }
+        }
+        ScreenshotsCmd::Delete {
+            screenshot,
+            instance,
+        } => {
+            let shot = screenshots::find(&home(instance)?, &screenshot)?;
+            screenshots::delete(&shot)?;
+            println!("{} is in the trash.", shot.name);
+        }
+    }
+    Ok(())
+}
+
+fn multiplayer(action: MultiplayerCmd, as_json: bool) -> Result<(), String> {
+    let home = |instance: Option<String>| -> Result<PathBuf, String> {
+        Ok(match instance {
+            Some(name) => instances::find(&name)?.home,
+            None => instances::selected().home,
+        })
+    };
+    match action {
+        MultiplayerCmd::List { instance } => {
+            let home = home(instance)?;
+            let servers = server_list::List::load(&home).servers();
+            if as_json {
+                json(
+                    servers
+                        .iter()
+                        .map(|s| serde_json::json!({ "name": s.name, "address": s.ip, "icon": s.icon.is_some() }))
+                        .collect(),
+                );
+            } else if servers.is_empty() {
+                println!("No servers in {}", home.join("servers.dat").display());
+            }
+            for (i, s) in servers.iter().enumerate().filter(|_| !as_json) {
+                println!("{}. {} ({})", i + 1, s.name, s.ip);
+            }
+        }
+        MultiplayerCmd::Add {
+            address,
+            name,
+            instance,
+        } => {
+            let home = home(instance)?;
+            let mut list = server_list::List::load(&home);
+            list.add(name.as_deref().unwrap_or(""), &address)?;
+            list.save(&home)?;
+            println!("Added {}.", address.trim());
+        }
+        MultiplayerCmd::Remove { server, instance } => {
+            let home = home(instance)?;
+            let mut list = server_list::List::load(&home);
+            let (i, _) = server_list::find(&list, &server)?;
+            let gone = list.remove(i)?;
+            list.save(&home)?;
+            println!("Removed {} ({}).", gone.name, gone.ip);
+        }
+    }
+    Ok(())
+}
+
+fn worlds(action: WorldsCmd, as_json: bool) -> Result<(), String> {
+    use horizon_launcher::datapacks;
+    use horizon_launcher::worlds::{self, World};
+    let home = |instance: Option<String>| -> Result<PathBuf, String> {
+        Ok(match instance {
+            Some(name) => instances::find(&name)?.home,
+            None => instances::selected().home,
+        })
+    };
+    let value = |w: &World| {
+        let millis = w
+            .last_played
+            .duration_since(std::time::UNIX_EPOCH)
+            .map_or(0, |d| d.as_millis() as u64);
+        serde_json::json!({
+            "folder": w.folder, "name": w.name, "mode": w.mode, "version": w.version,
+            "last_played_ms": millis, "size": w.size, "path": w.path, "icon": w.icon,
+        })
+    };
+    match action {
+        WorldsCmd::List { instance } => {
+            let home = home(instance)?;
+            let all = worlds::list(&home);
+            if as_json {
+                json(all.iter().map(value).collect());
+            } else if all.is_empty() {
+                println!("No worlds in {}", home.join("saves").display());
+            }
+            for w in all.iter().filter(|_| !as_json) {
+                let version = w.version.as_deref().unwrap_or("unknown version");
+                let mb = w.size as f64 / 1_000_000.0;
+                println!(
+                    "{} ({})\n    {}, {version}, {mb:.1} MB",
+                    w.name, w.folder, w.mode
+                );
+            }
+        }
+        WorldsCmd::Backup { world, instance } => {
+            let home = home(instance)?;
+            let zip = worlds::backup(&home, &worlds::find(&home, &world)?)?;
+            match as_json {
+                true => json(serde_json::json!({ "backup": zip })),
+                false => println!("{}", zip.display()),
+            }
+        }
+        WorldsCmd::Copy { world, instance } => {
+            let home = home(instance)?;
+            let copy = worlds::copy(&worlds::find(&home, &world)?)?;
+            match as_json {
+                true => json(value(&copy)),
+                false => println!("Copied to {} ({})", copy.name, copy.folder),
+            }
+        }
+        WorldsCmd::Delete { world, instance } => {
+            let home = home(instance)?;
+            let w = worlds::find(&home, &world)?;
+            worlds::delete(&w)?;
+            println!("{} is in the trash.", w.name);
+        }
+        WorldsCmd::DatapackList { world, instance } => {
+            let w = worlds::find(&home(instance)?, &world)?;
+            let packs = datapacks::list(&w.path);
+            if as_json {
+                json(
+                    packs
+                        .iter()
+                        .map(|p| serde_json::json!({ "file": p.file, "description": p.description, "enabled": p.enabled, "path": p.path }))
+                        .collect(),
+                );
+            } else if packs.is_empty() {
+                println!("No data packs in {}", w.name);
+            }
+            for p in packs.iter().filter(|_| !as_json) {
+                let on = if p.enabled { "on " } else { "off" };
+                println!("  {on} {}  {}", p.file, p.description);
+            }
+        }
+        WorldsCmd::DatapackAdd {
+            world,
+            file,
+            instance,
+        } => {
+            let w = worlds::find(&home(instance)?, &world)?;
+            let p = datapacks::add(&w.path, &file)?;
+            println!(
+                "Added {} to {}: the game turns it on when the world opens.",
+                p.file, w.name
+            );
+        }
+        WorldsCmd::DatapackRemove {
+            world,
+            pack,
+            instance,
+        } => {
+            let w = worlds::find(&home(instance)?, &world)?;
+            let p = datapacks::find(&w.path, &pack)?;
+            datapacks::remove(&w.path, &p)?;
+            println!("{} is in the trash.", p.file);
+        }
+    }
+    Ok(())
+}
+
 fn modpack(action: ModpackCmd, as_json: bool) -> Result<(), String> {
     use horizon_launcher::browser::horizon;
     use horizon_launcher::modpacks::{self, Imported};
@@ -1468,4 +2629,39 @@ mod tests {
             _ => panic!("expected game-args"),
         }
     }
+
+    #[test]
+    fn mods_commands_name_their_instance() {
+        let parse = |args: &[&str]| {
+            let cli = Cli::try_parse_from([&["horizon-launcher", "mods"], args].concat()).unwrap();
+            match cli.command {
+                Some(Cmd::Mods { action }) => action,
+                _ => panic!("expected mods"),
+            }
+        };
+        match parse(&["install", "fresh-animations", "--instance", "Skyblock"]) {
+            Some(ModsCmd::Install {
+                project, instance, ..
+            }) => assert_eq!(
+                (project.as_str(), instance.as_deref()),
+                ("fresh-animations", Some("Skyblock"))
+            ),
+            _ => panic!("expected mods install"),
+        }
+        assert!(matches!(
+            parse(&["list"]),
+            Some(ModsCmd::List { instance: None })
+        ));
+        assert!(parse(&[]).is_none());
+        // Search and Check read no instance: checks are shared.
+        assert!(Cli::try_parse_from([
+            "horizon-launcher",
+            "mods",
+            "search",
+            "x",
+            "--instance",
+            "A"
+        ])
+        .is_err());
+    }
 }
diff --git a/launcher/src/cli_tools.rs b/launcher/src/cli_tools.rs
index 45763296a..a6ddbfa34 100644
--- a/launcher/src/cli_tools.rs
+++ b/launcher/src/cli_tools.rs
@@ -26,6 +26,14 @@ pub const DESTRUCTIVE: &[&str] = &[
     "servers forget",
     "account sign-out",
     "data delete",
+    "worlds delete",
+    "multiplayer remove",
+    "screenshots delete",
+    "packs remove",
+    "worlds datapack-remove",
+    "unshare-log",
+    // It sets shell commands the next Play runs: the player says yes first.
+    "instance launch",
 ];
 
 /// Commands that send something or reach other people: only when the player asks.
@@ -35,6 +43,7 @@ pub const OPEN_WORLD: &[&str] = &[
     "data bug",
     "data benchmark",
     "servers create",
+    "share-log",
 ];
 
 /// A generated tool: its name, the CLI words it runs and the clap command behind them.
diff --git a/launcher/src/console_page.rs b/launcher/src/console_page.rs
new file mode 100644
index 000000000..5e26a624e
--- /dev/null
+++ b/launcher/src/console_page.rs
@@ -0,0 +1,320 @@
+//! Home's Console: the game's output of this run as it comes, with a search, Follow (keep the
+//! newest line in view), Copy, and Share log (`horizon_launcher::game_log`): an upload to mclo.gs
+//! that happens only after the player confirms, without their home folder or names.
+use super::servers_page::Field;
+use super::*;
+use gpui::{ClipboardItem, ScrollHandle};
+use horizon_launcher::game_log::{self, Shared};
+
+pub(super) struct Console {
+    open: bool,
+    follow: bool,
+    scroll: ScrollHandle,
+    /// Lines and search at the last draw: a change means scroll down when following.
+    seen: (usize, String),
+    confirm_share: bool,
+    sharing: bool,
+    shared: Option<Result<Shared, String>>,
+}
+
+impl Default for Console {
+    fn default() -> Self {
+        Console {
+            open: std::env::var("HORIZON_LAUNCHER_CONSOLE").is_ok(),
+            follow: true,
+            scroll: ScrollHandle::new(),
+            seen: (0, String::new()),
+            confirm_share: false,
+            sharing: false,
+            shared: None,
+        }
+    }
+}
+
+impl Launcher {
+    /// What Share log sends: this run's lines, else the selected instance's latest.log.
+    fn log_to_share(&self) -> Result<(String, Vec<std::path::PathBuf>), String> {
+        let home = self
+            .client_home
+            .clone()
+            .or_else(|| self.selected_instance().map(|i| i.home.clone()))
+            .unwrap_or_else(backend::game_home);
+        let text = match self.prepare_log.is_empty() {
+            false => {
+                self.prepare_log
+                    .iter()
+                    .cloned()
+                    .collect::<Vec<_>>()
+                    .join("\n")
+                    + "\n"
+            }
+            true => {
+                let path = home.join("logs/latest.log");
+                std::fs::read_to_string(&path).map_err(|_| "There is no log to share yet.")?
+            }
+        };
+        Ok((text, vec![home, backend::game_home()]))
+    }
+
+    fn share_log(&mut self, cx: &mut Context<Self>) {
+        let shared = match self.log_to_share() {
+            Ok(log) => log,
+            Err(e) => {
+                self.console.shared = Some(Err(e));
+                return;
+            }
+        };
+        self.console.confirm_share = false;
+        self.console.sharing = true;
+        let task = cx.background_executor().spawn(async move {
+            let (text, homes) = shared;
+            let homes: Vec<&std::path::Path> = homes.iter().map(|h| h.as_path()).collect();
+            let names = game_log::names(&homes);
+            game_log::share(&game_log::private(
+                &text,
+                dirs::home_dir().as_deref(),
+                &names,
+            ))
+        });
+        cx.spawn(async move |this, cx| {
+            let done = task.await;
+            let _ = this.update(cx, |this, cx| {
+                this.console.sharing = false;
+                this.console.shared = Some(done);
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    fn unshare_log(&mut self, cx: &mut Context<Self>) {
+        let Some(Ok(shared)) = self.console.shared.clone() else {
+            return;
+        };
+        self.console.sharing = true;
+        let task = cx
+            .background_executor()
+            .spawn(async move { game_log::unshare(&shared) });
+        cx.spawn(async move |this, cx| {
+            let done = task.await;
+            let _ = this.update(cx, |this, cx| {
+                this.console.sharing = false;
+                this.console.shared = match done {
+                    Ok(()) => None,
+                    Err(e) => Some(Err(e)),
+                };
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    /// Home's Console section, once the game has said something (or is running).
+    pub(super) fn console_section(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        if self.prepare_log.is_empty() && self.client.is_none() {
+            return None;
+        }
+        let open = self.console.open;
+        let toggle = button(
+            "console-toggle",
+            if open { "Hide" } else { "Show" },
+            Kind::Ghost,
+            &t,
+        )
+        .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+            this.console.open = !this.console.open;
+            cx.notify();
+        }));
+        let count = self.prepare_log.len();
+        let header = div()
+            .flex()
+            .items_center()
+            .justify_between()
+            .child(section_title("Console", "terminal", &t))
+            .child(
+                div()
+                    .flex()
+                    .items_center()
+                    .gap(px(10.))
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.muted)
+                            .child(match self.client {
+                                Some(_) => format!("{count} lines, the game is running"),
+                                None => format!("{count} lines from the last run"),
+                            }),
+                    )
+                    .child(toggle),
+            );
+        let mut section = div().flex().flex_col().gap(px(10.)).child(header);
+        if !open {
+            return Some(section);
+        }
+        let search = self.servers.value(Field::ConsoleSearch).trim().to_string();
+        let lines: Vec<String> = self
+            .prepare_log
+            .iter()
+            .filter(|l| game_log::matches(l, &search))
+            .cloned()
+            .collect();
+        let now = (count, search);
+        if self.console.follow && now != self.console.seen {
+            self.console.scroll.scroll_to_bottom();
+        }
+        self.console.seen = now;
+        let follow = div()
+            .id("console-follow")
+            .flex()
+            .items_center()
+            .gap(px(8.))
+            .cursor_pointer()
+            .child(switch("console-follow-switch", self.console.follow, &t))
+            .child(text(theme::LABEL).text_color(t.ink_soft).child("Follow"))
+            .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                this.console.follow = !this.console.follow;
+                this.console.seen.0 = usize::MAX;
+                cx.notify();
+            }));
+        let copied = lines.join("\n");
+        let tools = div()
+            .flex()
+            .flex_wrap()
+            .items_center()
+            .gap(px(10.))
+            .child(self.field(Field::ConsoleSearch, "Search the log", 260., cx))
+            .child(follow)
+            .child(div().flex_1())
+            .child(
+                button("console-copy", "Copy", Kind::Ghost, &t).on_click(cx.listener(
+                    move |this, _: &ClickEvent, _, cx| {
+                        copy_to_clipboard(cx, ClipboardItem::new_string(copied.clone()));
+                        this.console.shared = None;
+                        cx.notify();
+                    },
+                )),
+            )
+            .child({
+                let b = button("console-share", "Share log…", Kind::Ghost, &t);
+                match self.console.sharing {
+                    true => disabled(b),
+                    false => b.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                        this.console.confirm_share = true;
+                        cx.notify();
+                    })),
+                }
+            })
+            .child({
+                let logs = self
+                    .client_home
+                    .clone()
+                    .or_else(|| self.selected_instance().map(|i| i.home.clone()))
+                    .unwrap_or_else(backend::game_home)
+                    .join("logs");
+                button("console-folder", "Open logs folder", Kind::Ghost, &t).on_click(
+                    move |_, _, cx| {
+                        let _ = std::fs::create_dir_all(&logs);
+                        cx.open_with_system(&logs);
+                    },
+                )
+            });
+        section = section.child(tools);
+        if self.console.confirm_share {
+            section = section.child(
+                plate(&t)
+                    .flex()
+                    .items_center()
+                    .gap(px(12.))
+                    .px(px(14.))
+                    .py(px(10.))
+                    .child(div().flex_1().min_w_0().child(
+                        text(theme::CAPTION).text_color(t.ink_soft).child(
+                            "Upload this log to mclo.gs, a paste service for Minecraft logs? \
+                             Anyone with the link can read it, until it is deleted or unread \
+                             for 90 days. Your home folder, user name and account names are \
+                             taken out first.",
+                        ),
+                    ))
+                    .child(
+                        button("console-share-no", "Cancel", Kind::Ghost, &t).on_click(
+                            cx.listener(|this, _: &ClickEvent, _, cx| {
+                                this.console.confirm_share = false;
+                                cx.notify();
+                            }),
+                        ),
+                    )
+                    .child(
+                        button("console-share-yes", "Upload", Kind::Secondary, &t).on_click(
+                            cx.listener(|this, _: &ClickEvent, _, cx| {
+                                this.share_log(cx);
+                                cx.notify();
+                            }),
+                        ),
+                    ),
+            );
+        }
+        match &self.console.shared {
+            _ if self.console.sharing => {
+                section = section.child(text(theme::CAPTION).text_color(t.muted).child("Sending…"))
+            }
+            Some(Ok(shared)) => {
+                let (url, open_url) = (shared.url.clone(), shared.url.clone());
+                section = section.child(
+                    div()
+                        .flex()
+                        .items_center()
+                        .gap(px(10.))
+                        .child(
+                            text(theme::CAPTION)
+                                .text_color(t.ink_soft)
+                                .child(format!("Shared: {url}")),
+                        )
+                        .child(
+                            button("console-link-copy", "Copy link", Kind::Ghost, &t).on_click(
+                                move |_, _, cx| {
+                                    copy_to_clipboard(cx, ClipboardItem::new_string(url.clone()))
+                                },
+                            ),
+                        )
+                        .child(
+                            button("console-link-open", "Open", Kind::Ghost, &t)
+                                .on_click(move |_, _, cx| cx.open_url(&open_url)),
+                        )
+                        .child(
+                            button("console-unshare", "Delete it", Kind::Ghost, &t).on_click(
+                                cx.listener(|this, _: &ClickEvent, _, cx| {
+                                    this.unshare_log(cx);
+                                    cx.notify();
+                                }),
+                            ),
+                        ),
+                );
+            }
+            Some(Err(e)) => section = section.child(notice(e.clone(), &t)),
+            None => {}
+        }
+        let shown = lines.len().saturating_sub(LOG_LINES);
+        let body = div()
+            .id("console-lines")
+            .track_scroll(&self.console.scroll)
+            .h(px(320.))
+            .overflow_y_scroll()
+            .p(px(10.))
+            .border_2()
+            .border_color(t.outline)
+            .bg(t.well)
+            .font_family(theme::MONO)
+            .text_size(px(12.))
+            .children(lines.into_iter().skip(shown).map(|line| {
+                let color = if line.contains("/ERROR]") || line.contains("ERROR:") {
+                    t.danger
+                } else if line.contains("/WARN]") {
+                    t.warn
+                } else {
+                    t.ink_soft
+                };
+                div().text_color(color).child(line)
+            }));
+        Some(section.child(body))
+    }
+}
diff --git a/launcher/src/datapacks.rs b/launcher/src/datapacks.rs
new file mode 100644
index 000000000..956a1dffe
--- /dev/null
+++ b/launcher/src/datapacks.rs
@@ -0,0 +1,232 @@
+//! A world's data packs: `<world>/datapacks/`, each a `.zip` or a folder with a `pack.mcmeta`, as
+//! the game discovers them (`datapack::discover`). The game turns on every pack it finds there
+//! that `<world>/datapacks.json` doesn't list as disabled, when the world opens or on `/reload`,
+//! so adding one is copying it in.
+use crate::packs::{entry, plain};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+const SETTINGS: &str = "datapacks.json";
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct DataPack {
+    /// Its file or folder name in `datapacks/`; the game's id is `file/<name>`.
+    pub file: String,
+    pub path: PathBuf,
+    /// `pack.mcmeta`'s description as plain text.
+    pub description: String,
+    /// Off when `datapacks.json` lists it as disabled (the game's `/datapack disable`).
+    pub enabled: bool,
+}
+
+fn settings(world: &Path) -> serde_json::Value {
+    fs::read(world.join(SETTINGS))
+        .ok()
+        .and_then(|b| serde_json::from_slice(&b).ok())
+        .unwrap_or_else(|| serde_json::json!({}))
+}
+
+fn disabled(settings: &serde_json::Value) -> Vec<String> {
+    settings["disabled"]
+        .as_array()
+        .into_iter()
+        .flatten()
+        .filter_map(|v| v.as_str().map(str::to_string))
+        .collect()
+}
+
+/// The data packs of the world folder `world`, by name.
+pub fn list(world: &Path) -> Vec<DataPack> {
+    let off = disabled(&settings(world));
+    let mut packs: Vec<DataPack> = fs::read_dir(world.join("datapacks"))
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter_map(|e| {
+            let path = e.path();
+            let file = e.file_name().to_str()?.to_string();
+            let zip = path.is_file() && file.to_ascii_lowercase().ends_with(".zip");
+            if !(zip || path.is_dir()) {
+                return None;
+            }
+            let meta: serde_json::Value =
+                serde_json::from_slice(&entry(&path, "pack.mcmeta")?).ok()?;
+            Some(DataPack {
+                enabled: !off.contains(&format!("file/{file}")),
+                description: plain(&meta["pack"]["description"]),
+                file,
+                path,
+            })
+        })
+        .collect();
+    packs.sort_by_key(|p| p.file.to_lowercase());
+    packs
+}
+
+/// Whether a zip is a data pack: a `pack.mcmeta` and a `data/` folder.
+fn check(file: &Path) -> Result<(), String> {
+    let name = file
+        .file_name()
+        .map(|n| n.to_string_lossy().into_owned())
+        .unwrap_or_default();
+    let zip = fs::File::open(file)
+        .ok()
+        .and_then(|f| zip::ZipArchive::new(f).ok())
+        .ok_or_else(|| format!("{name} is not a zip file that can be read."))?;
+    if zip.index_for_name("pack.mcmeta").is_none() {
+        return Err(format!("{name} is not a pack: it has no pack.mcmeta."));
+    }
+    if !zip.file_names().any(|n| n.starts_with("data/")) {
+        return Err(format!(
+            "{name} has no data folder: it is a resource pack, not a data pack."
+        ));
+    }
+    Ok(())
+}
+
+/// Copies a data pack zip into the world's `datapacks/` under a free name. The game turns it on
+/// the next time the world opens (or on `/reload`).
+pub fn add(world: &Path, file: &Path) -> Result<DataPack, String> {
+    check(file)?;
+    let dir = world.join("datapacks");
+    fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let name = file.file_name().ok_or("A pack file has a name")?;
+    let stem = Path::new(name)
+        .file_stem()
+        .unwrap_or(name)
+        .to_string_lossy();
+    let target = (1..)
+        .map(|n| match n {
+            1 => dir.join(name),
+            n => dir.join(format!("{stem} ({n}).zip")),
+        })
+        .find(|p| !p.exists())
+        .unwrap();
+    fs::copy(file, &target).map_err(|e| format!("Could not copy {}: {e}", file.display()))?;
+    let file_name = target.file_name().unwrap().to_string_lossy().into_owned();
+    // A pack of the same name removed while it was disabled would stay off.
+    forget(world, &file_name)?;
+    list(world)
+        .into_iter()
+        .find(|p| p.file == file_name)
+        .ok_or_else(|| format!("{} is not a data pack the game reads", target.display()))
+}
+
+/// Drops `file/<name>` from both lists of `datapacks.json`, when it is there.
+fn forget(world: &Path, file: &str) -> Result<(), String> {
+    let mut s = settings(world);
+    let id = format!("file/{file}");
+    let mut changed = false;
+    for key in ["enabled", "disabled"] {
+        if let Some(list) = s[key].as_array_mut() {
+            let before = list.len();
+            list.retain(|v| v.as_str() != Some(id.as_str()));
+            changed |= list.len() != before;
+        }
+    }
+    if !changed {
+        return Ok(());
+    }
+    let text = serde_json::to_string_pretty(&s).unwrap();
+    fs::write(world.join(SETTINGS), text).map_err(|e| format!("{SETTINGS}: {e}"))
+}
+
+/// The data pack a command names: its file name, with or without `.zip`.
+pub fn find(world: &Path, query: &str) -> Result<DataPack, String> {
+    list(world)
+        .into_iter()
+        .find(|p| p.file == query || p.file.strip_suffix(".zip") == Some(query))
+        .ok_or_else(|| {
+            format!(
+                "No data pack {query} in {}",
+                world.join("datapacks").display()
+            )
+        })
+}
+
+/// Moves the data pack to the system's trash and forgets it in `datapacks.json`.
+pub fn remove(world: &Path, pack: &DataPack) -> Result<(), String> {
+    crate::desktop_seams::to_trash(&pack.path)
+        .map_err(|e| format!("Could not move {} to the trash: {e}", pack.file))?;
+    forget(world, &pack.file)
+}
+
+/// What of a data pack the game reads today (its `DataStore`): `data/<namespace>/<kind>/`.
+pub const READ: [&str; 4] = ["function", "function tag", "predicate", "item_modifier"];
+
+/// A data pack's files by kind (`function`, `worldgen`, `item tag`...), with how many each.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Coverage {
+    /// What Horizon runs.
+    pub read: Vec<(String, usize)>,
+    /// What it doesn't read yet.
+    pub unread: Vec<(String, usize)>,
+}
+
+impl Coverage {
+    /// "Runs its 12 functions, 1 predicate. Not read yet: 40 worldgen, 3 recipes."
+    pub fn summary(&self) -> String {
+        let runs = match self.read.is_empty() {
+            true => "Nothing in it runs in Horizon yet.".to_string(),
+            false => format!("Runs its {}.", counts(&self.read)),
+        };
+        match self.unread.is_empty() {
+            true => runs,
+            false => format!("{runs} Not read yet: {}.", self.not_read()),
+        }
+    }
+
+    /// "1077 worldgen, 653 loot tables, 16 recipes": what Horizon doesn't read yet, the six
+    /// biggest kinds and how many other kinds.
+    pub fn not_read(&self) -> String {
+        let mut biggest = self.unread.clone();
+        biggest.sort_by_key(|(_, n)| std::cmp::Reverse(*n));
+        let others = biggest.len().saturating_sub(6);
+        biggest.truncate(6);
+        match others {
+            0 => counts(&biggest),
+            1 => format!("{} and 1 other kind", counts(&biggest)),
+            n => format!("{} and {n} other kinds", counts(&biggest)),
+        }
+    }
+}
+
+fn counts(list: &[(String, usize)]) -> String {
+    list.iter()
+        .map(|(k, n)| {
+            let k = k.replace('_', " ");
+            match *n == 1 || k == "worldgen" {
+                true => format!("{n} {k}"),
+                false => format!("{n} {k}s"),
+            }
+        })
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+/// Counts a data pack zip's files by kind, and splits them into what the game reads and what
+/// it doesn't yet.
+pub fn coverage(file: &Path) -> Result<Coverage, String> {
+    let zip = fs::File::open(file)
+        .ok()
+        .and_then(|f| zip::ZipArchive::new(f).ok())
+        .ok_or_else(|| format!("{} is not a zip file that can be read.", file.display()))?;
+    let mut kinds = std::collections::BTreeMap::<String, usize>::new();
+    for name in zip.file_names().filter(|n| !n.ends_with('/')) {
+        let parts: Vec<&str> = name.split('/').collect();
+        let kind = match parts.as_slice() {
+            ["data", _, "tags", tag, _, ..] => format!("{tag} tag"),
+            ["data", _, kind, _, ..] => kind.to_string(),
+            _ => continue,
+        };
+        *kinds.entry(kind).or_default() += 1;
+    }
+    let (read, unread) = kinds
+        .into_iter()
+        .partition(|(k, _)| READ.contains(&k.as_str()));
+    Ok(Coverage { read, unread })
+}
+
+#[cfg(test)]
+#[path = "datapacks/tests.rs"]
+mod tests;
diff --git a/launcher/src/datapacks/tests.rs b/launcher/src/datapacks/tests.rs
new file mode 100644
index 000000000..f5695c706
--- /dev/null
+++ b/launcher/src/datapacks/tests.rs
@@ -0,0 +1,138 @@
+use super::*;
+use std::io::Write;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-datapacks-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+fn zip_file(path: &Path, files: &[(&str, &str)]) {
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    let mut zip = zip::ZipWriter::new(fs::File::create(path).unwrap());
+    for (name, text) in files {
+        zip.start_file(*name, zip::write::SimpleFileOptions::default())
+            .unwrap();
+        zip.write_all(text.as_bytes()).unwrap();
+    }
+    zip.finish().unwrap();
+}
+
+const META: &str = r#"{"pack":{"pack_format":88,"description":"More trades"}}"#;
+
+#[test]
+fn lists_adds_and_removes_as_the_game_reads_them() {
+    let root = scratch("all");
+    let world = root.join("saves/My World");
+    zip_file(
+        &world.join("datapacks/Trades.zip"),
+        &[
+            ("pack.mcmeta", META),
+            ("data/t/function/a.mcfunction", "say hi"),
+        ],
+    );
+    fs::create_dir_all(world.join("datapacks/folder pack")).unwrap();
+    fs::write(
+        world.join("datapacks/folder pack/pack.mcmeta"),
+        r#"{"pack":{"description":{"text":"Mine"}}}"#,
+    )
+    .unwrap();
+    fs::write(world.join("datapacks/readme.txt"), "").unwrap();
+    fs::write(
+        world.join("datapacks.json"),
+        r#"{"enabled":[],"disabled":["file/folder pack","file/Gone.zip"]}"#,
+    )
+    .unwrap();
+    let packs = list(&world);
+    let seen: Vec<(&str, &str, bool)> = packs
+        .iter()
+        .map(|p| (p.file.as_str(), p.description.as_str(), p.enabled))
+        .collect();
+    assert_eq!(
+        seen,
+        [
+            ("folder pack", "Mine", false),
+            ("Trades.zip", "More trades", true)
+        ]
+    );
+
+    let drops = root.join("drops");
+    zip_file(
+        &drops.join("Gone.zip"),
+        &[("pack.mcmeta", META), ("data/g/tags/x.json", "{}")],
+    );
+    zip_file(
+        &drops.join("Trades.zip"),
+        &[("pack.mcmeta", META), ("data/t/function/b.mcfunction", "")],
+    );
+    zip_file(
+        &drops.join("Textures.zip"),
+        &[
+            ("pack.mcmeta", META),
+            ("assets/minecraft/textures/a.png", ""),
+        ],
+    );
+    // A pack disabled before it was taken out comes back on.
+    let gone = add(&world, &drops.join("Gone.zip")).unwrap();
+    assert!(gone.enabled);
+    assert!(!fs::read_to_string(world.join("datapacks.json"))
+        .unwrap()
+        .contains("Gone.zip"));
+    assert_eq!(
+        add(&world, &drops.join("Trades.zip")).unwrap().file,
+        "Trades (2).zip"
+    );
+    let refused = add(&world, &drops.join("Textures.zip")).unwrap_err();
+    assert!(refused.contains("resource pack"), "{refused}");
+
+    let folder = find(&world, "folder pack").unwrap();
+    let trash = root.join("trash");
+    std::env::set_var(crate::desktop_seams::TRASH_ENV, &trash);
+    remove(&world, &folder).unwrap();
+    std::env::remove_var(crate::desktop_seams::TRASH_ENV);
+    assert!(trash.join("folder pack/pack.mcmeta").is_file());
+    assert!(!fs::read_to_string(world.join("datapacks.json"))
+        .unwrap()
+        .contains("folder pack"));
+    assert_eq!(find(&world, "Trades").unwrap().file, "Trades.zip");
+    fs::remove_dir_all(&root).unwrap();
+}
+
+#[test]
+fn coverage_says_what_runs() {
+    let root = scratch("coverage");
+    let file = root.join("p.zip");
+    zip_file(
+        &file,
+        &[
+            ("pack.mcmeta", META),
+            ("data/a/function/x.mcfunction", ""),
+            ("data/a/predicate/p.json", "{}"),
+            ("data/a/item_modifier/m.json", "{}"),
+            ("data/a/tags/item/i.json", "{}"),
+            ("data/a/loot_table/l.json", "{}"),
+            ("data/a/loot_table/k.json", "{}"),
+            ("data/a/worldgen/biome/b.json", "{}"),
+            ("assets/a/lang/en_us.json", "{}"),
+        ],
+    );
+    let c = coverage(&file).unwrap();
+    assert_eq!(
+        c.summary(),
+        "Runs its 1 function, 1 item modifier, 1 predicate. Not read yet: 2 loot tables, 1 item \
+         tag, 1 worldgen."
+    );
+    let many = Coverage {
+        read: Vec::new(),
+        unread: (1..=8).map(|n| (format!("kind{n}"), n)).collect(),
+    };
+    assert_eq!(
+        many.not_read(),
+        "8 kind8s, 7 kind7s, 6 kind6s, 5 kind5s, 4 kind4s, 3 kind3s and 2 other kinds"
+    );
+    fs::remove_dir_all(&root).unwrap();
+}
diff --git a/launcher/src/datapacks_page.rs b/launcher/src/datapacks_page.rs
new file mode 100644
index 000000000..29c5ed9ba
--- /dev/null
+++ b/launcher/src/datapacks_page.rs
@@ -0,0 +1,266 @@
+//! A world's data packs, opened under its row on Home (`horizon_launcher::datapacks`): what is
+//! in `datapacks/`, Add (a file picker) or a zip dropped on the world, and Remove (to the trash,
+//! after a confirmation).
+use super::*;
+use gpui::ExternalPaths;
+use horizon_launcher::datapacks::{self, DataPack};
+use horizon_launcher::worlds::World;
+use std::path::PathBuf;
+
+#[derive(Default)]
+pub(super) struct WorldPacks {
+    /// The world whose packs are open, and its packs as last read.
+    open: Option<PathBuf>,
+    list: Vec<DataPack>,
+    confirm_remove: Option<String>,
+    note: Option<Result<String, String>>,
+}
+
+impl WorldPacks {
+    /// Reads the open world's packs again, after something else changed them.
+    pub(super) fn reread(&mut self) {
+        if let Some(world) = &self.open {
+            self.list = datapacks::list(world);
+        }
+    }
+}
+
+impl Launcher {
+    /// Opens or closes the packs of `world` under its row.
+    pub(super) fn toggle_world_packs(&mut self, world: &World) {
+        if self.world_packs.open.as_ref() == Some(&world.path) {
+            self.world_packs = WorldPacks::default();
+        } else {
+            self.world_packs = WorldPacks {
+                open: Some(world.path.clone()),
+                list: datapacks::list(&world.path),
+                ..WorldPacks::default()
+            };
+        }
+    }
+
+    pub(super) fn world_packs_open(&self, world: &World) -> bool {
+        self.world_packs.open.as_ref() == Some(&world.path)
+    }
+
+    /// Copies dropped or picked zips into `world`, and opens its packs to show them.
+    pub(super) fn add_world_packs(&mut self, world: PathBuf, files: Vec<PathBuf>) {
+        let added: Result<Vec<String>, String> = files
+            .iter()
+            .map(|f| datapacks::add(&world, f).map(|p| p.file))
+            .collect();
+        self.world_packs = WorldPacks {
+            list: datapacks::list(&world),
+            note: Some(added.map(|names| {
+                format!(
+                    "Added {}: the game turns it on when the world opens.",
+                    names.join(", ")
+                )
+            })),
+            open: Some(world),
+            confirm_remove: None,
+        };
+    }
+
+    fn choose_world_packs(&mut self, world: PathBuf, cx: &mut Context<Self>) {
+        let paths = cx.prompt_for_paths(PathPromptOptions {
+            files: true,
+            directories: false,
+            multiple: true,
+            prompt: Some("Add".into()),
+        });
+        cx.spawn(async move |this, cx| {
+            if let Ok(Ok(Some(paths))) = paths.await {
+                let _ = this.update(cx, |this, cx| {
+                    this.add_world_packs(world, paths);
+                    cx.notify();
+                });
+            }
+        })
+        .detach();
+    }
+
+    /// A world row that takes dropped data packs.
+    pub(super) fn world_drop_target(
+        &self,
+        i: usize,
+        world: &World,
+        row: Div,
+        cx: &mut Context<Self>,
+    ) -> Stateful<Div> {
+        let t = self.theme;
+        let path = world.path.clone();
+        div()
+            .id(SharedString::from(format!("world-drop-{i}")))
+            .border_2()
+            .mx(px(-4.))
+            .p(px(2.))
+            .border_color(gpui::transparent_black())
+            .drag_over::<ExternalPaths>(move |s, _, _, _| s.border_color(t.accent))
+            .on_drop(cx.listener(move |this, paths: &ExternalPaths, _, cx| {
+                this.add_world_packs(path.clone(), paths.paths().to_vec());
+                // Not the window's import as well.
+                cx.stop_propagation();
+                cx.notify();
+            }))
+            .child(row)
+    }
+
+    /// The open world's packs, under its row.
+    pub(super) fn world_packs_panel(
+        &mut self,
+        world: &World,
+        cx: &mut Context<Self>,
+    ) -> Option<Div> {
+        if !self.world_packs_open(world) {
+            return None;
+        }
+        let t = self.theme;
+        let path = world.path.clone();
+        let mut panel = div()
+            .flex()
+            .flex_col()
+            .gap(px(6.))
+            .ml(px(62.))
+            .mb(px(6.))
+            .child(
+                div()
+                    .flex()
+                    .items_center()
+                    .justify_between()
+                    .child(caps("Data packs").text_color(t.muted))
+                    .child(
+                        div()
+                            .flex()
+                            .gap(px(6.))
+                            .child(
+                                button("world-packs-add", "Add data pack…", Kind::Ghost, &t)
+                                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                                        this.choose_world_packs(path.clone(), cx);
+                                        cx.notify();
+                                    })),
+                            )
+                            .child({
+                                let dir = world.path.join("datapacks");
+                                button("world-packs-folder", "Open folder", Kind::Ghost, &t)
+                                    .on_click(move |_, _, cx| {
+                                        let _ = std::fs::create_dir_all(&dir);
+                                        cx.open_with_system(&dir);
+                                    })
+                            }),
+                    ),
+            );
+        match &self.world_packs.note {
+            Some(Ok(m)) => {
+                panel = panel.child(text(theme::CAPTION).text_color(t.muted).child(m.clone()))
+            }
+            Some(Err(e)) => panel = panel.child(notice(e.clone(), &t)),
+            None => {}
+        }
+        if self.world_packs.list.is_empty() {
+            panel = panel.child(
+                text(theme::CAPTION)
+                    .text_color(t.muted)
+                    .child("None yet: drop a data pack .zip on the world, or use Add data pack…"),
+            );
+        }
+        for (i, pack) in self.world_packs.list.clone().into_iter().enumerate() {
+            let confirming = self.world_packs.confirm_remove.as_ref() == Some(&pack.file);
+            let mut actions = div().flex().items_center().gap(px(6.));
+            if confirming {
+                let (world, gone) = (world.path.clone(), pack.clone());
+                actions = actions
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.danger)
+                            .child("Move it to the trash?"),
+                    )
+                    .child(
+                        button(
+                            SharedString::from(format!("world-pack-keep-{i}")),
+                            "Keep",
+                            Kind::Ghost,
+                            &t,
+                        )
+                        .on_click(cx.listener(
+                            |this, _: &ClickEvent, _, cx| {
+                                this.world_packs.confirm_remove = None;
+                                cx.notify();
+                            },
+                        )),
+                    )
+                    .child(
+                        button(
+                            SharedString::from(format!("world-pack-trash-{i}")),
+                            "Move to trash",
+                            Kind::Secondary,
+                            &t,
+                        )
+                        .on_click(cx.listener(
+                            move |this, _: &ClickEvent, _, cx| {
+                                let note = datapacks::remove(&world, &gone)
+                                    .map(|()| format!("{} moved to the trash.", gone.file));
+                                this.world_packs.list = datapacks::list(&world);
+                                this.world_packs.note = Some(note);
+                                this.world_packs.confirm_remove = None;
+                                cx.notify();
+                            },
+                        )),
+                    );
+            } else {
+                let file = pack.file.clone();
+                if !pack.enabled {
+                    actions = actions.child(
+                        text(theme::CAPTION)
+                            .text_color(t.muted)
+                            .child("Off in the game"),
+                    );
+                }
+                actions = actions.child(
+                    button(
+                        SharedString::from(format!("world-pack-remove-{i}")),
+                        "Remove",
+                        Kind::Ghost,
+                        &t,
+                    )
+                    .on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            this.world_packs.confirm_remove = Some(file.clone());
+                            cx.notify();
+                        },
+                    )),
+                );
+            }
+            panel = panel.child(
+                plate(&t)
+                    .flex()
+                    .items_center()
+                    .gap(px(12.))
+                    .px(px(12.))
+                    .py(px(6.))
+                    .child(blocks::icon("package", 16., t.muted))
+                    .child(
+                        div()
+                            .flex()
+                            .flex_col()
+                            .flex_1()
+                            .min_w_0()
+                            .child(
+                                text(theme::LABEL)
+                                    .text_color(t.ink)
+                                    .truncate()
+                                    .child(pack.file.clone()),
+                            )
+                            .child(
+                                text(theme::CAPTION)
+                                    .text_color(t.muted)
+                                    .truncate()
+                                    .child(pack.description.clone()),
+                            ),
+                    )
+                    .child(actions),
+            );
+        }
+        Some(panel)
+    }
+}
diff --git a/launcher/src/desktop.rs b/launcher/src/desktop.rs
index 281850cb6..863923acb 100644
--- a/launcher/src/desktop.rs
+++ b/launcher/src/desktop.rs
@@ -65,7 +65,7 @@ pub fn data_home() -> Option<PathBuf> {
 }
 
 /// Quotes a path for an `Exec` key: inside double quotes, `"`, `` ` ``, `$` and `\` are escaped.
-fn quote(path: &Path) -> String {
+pub(crate) fn quote(path: &Path) -> String {
     let mut out = String::from("\"");
     for c in path.to_string_lossy().chars() {
         if matches!(c, '"' | '`' | '$' | '\\') {
@@ -215,7 +215,7 @@ pub fn needs_repair_in(data: &Path, path: Option<&OsStr>) -> bool {
 
 /// What the entry starts: a distributor's wrapper (`HORIZON_LAUNCHER_DESKTOP_EXEC`) when one is
 /// configured, else the binary at `exe`.
-fn target(exe: &Path) -> PathBuf {
+pub(crate) fn target(exe: &Path) -> PathBuf {
     std::env::var_os("HORIZON_LAUNCHER_DESKTOP_EXEC")
         .filter(|path| !path.is_empty())
         .map_or_else(|| exe.to_path_buf(), PathBuf::from)
diff --git a/launcher/src/desktop_seams.rs b/launcher/src/desktop_seams.rs
new file mode 100644
index 000000000..2815748ea
--- /dev/null
+++ b/launcher/src/desktop_seams.rs
@@ -0,0 +1,82 @@
+//! The two things the launcher does to the player's desktop that a test run must never do to the
+//! real one: moving files to the system's trash, and writing to the clipboard.
+//!
+//! - `HORIZON_LAUNCHER_TRASH=<folder>`: what would go to the trash is moved into that folder
+//!   instead (under a free name).
+//! - `HORIZON_LAUNCHER_CLIPBOARD=<file>`: what would be copied is written to that file instead
+//!   (text as UTF-8, a picture as its PNG or JPEG bytes).
+//!
+//! Test runs point both into their scratch folders, beside `HORIZON_HOME` and
+//! `HORIZON_LAUNCHER_HOME`, and `HORIZON_LAUNCHER_DESKTOP` too (`shortcut`: where desktop
+//! shortcuts go).
+use std::path::{Path, PathBuf};
+
+pub const TRASH_ENV: &str = "HORIZON_LAUNCHER_TRASH";
+pub const CLIPBOARD_ENV: &str = "HORIZON_LAUNCHER_CLIPBOARD";
+
+/// Moves a file or folder to the system's trash, where the player can still get it back, or
+/// into `HORIZON_LAUNCHER_TRASH` when it is set.
+pub fn to_trash(path: &Path) -> Result<(), String> {
+    match std::env::var_os(TRASH_ENV).filter(|v| !v.is_empty()) {
+        Some(dir) => to_folder(path, Path::new(&dir)),
+        None => system_trash(path),
+    }
+}
+
+/// Moves `path` into `dir` under a free name: the trash of a test run.
+pub fn to_folder(path: &Path, dir: &Path) -> Result<(), String> {
+    std::fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let name = path.file_name().ok_or("Nothing to move")?.to_string_lossy();
+    let target = (1..)
+        .map(|n| match n {
+            1 => dir.join(&*name),
+            n => dir.join(format!("{name} {n}")),
+        })
+        .find(|p| !p.exists())
+        .unwrap();
+    std::fs::rename(path, &target).map_err(|e| e.to_string())
+}
+
+fn system_trash(path: &Path) -> Result<(), String> {
+    #[allow(unused_mut)]
+    let mut trash = trash::TrashContext::default();
+    // The crate's default on macOS asks Finder through AppleScript, which needs the player to
+    // allow the launcher to control Finder first; the file manager call needs nothing.
+    #[cfg(target_os = "macos")]
+    trash::macos::TrashContextExtMacos::set_delete_method(
+        &mut trash,
+        trash::macos::DeleteMethod::NsFileManager,
+    );
+    trash.delete(path).map_err(|e| e.to_string())
+}
+
+/// The file copies go to instead of the clipboard, when `HORIZON_LAUNCHER_CLIPBOARD` is set.
+pub fn clipboard_file() -> Option<PathBuf> {
+    std::env::var_os(CLIPBOARD_ENV)
+        .filter(|v| !v.is_empty())
+        .map(PathBuf::from)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_trash_folder_takes_what_would_go_to_the_trash() {
+        let root = std::env::temp_dir().join(format!("horizon-seams-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&root);
+        let (home, bin) = (root.join("home"), root.join("trash"));
+        std::fs::create_dir_all(home.join("World/region")).unwrap();
+        std::fs::write(home.join("World/level.dat"), b"x").unwrap();
+        std::fs::write(home.join("shot.png"), b"1").unwrap();
+        to_folder(&home.join("World"), &bin).unwrap();
+        to_folder(&home.join("shot.png"), &bin).unwrap();
+        std::fs::write(home.join("shot.png"), b"2").unwrap();
+        to_folder(&home.join("shot.png"), &bin).unwrap();
+        assert!(bin.join("World/level.dat").is_file());
+        assert_eq!(std::fs::read(bin.join("shot.png")).unwrap(), b"1");
+        assert_eq!(std::fs::read(bin.join("shot.png 2")).unwrap(), b"2");
+        assert!(std::fs::read_dir(&home).unwrap().next().is_none());
+        std::fs::remove_dir_all(&root).unwrap();
+    }
+}
diff --git a/launcher/src/export.rs b/launcher/src/export.rs
new file mode 100644
index 000000000..c1a1b9e45
--- /dev/null
+++ b/launcher/src/export.rs
@@ -0,0 +1,286 @@
+//! Sharing an instance (or a port): its settings, packs and Horizon mods, and the worlds the
+//! player picks, as a `.mrpack` (Modrinth's modpack format, from its published spec) or a plain
+//! `.zip` of the game folder's layout.
+//!
+//! Only what makes the instance goes in, from a fixed list ([`FILES`], [`FOLDERS`]): never logs,
+//! screenshots, backups, caches, or anything tied to the player's account. A world goes without
+//! its per-player files (`playerdata/`, `stats/`, `advancements/`) and its level.dat without the
+//! player's UUID.
+//!
+//! In a `.mrpack`, a resource pack the browser installed from Modrinth, still the same file, is
+//! listed by its download (`files`, with its SHA-1 and SHA-512) instead of being copied; the
+//! rest goes under `overrides/`, which a launcher copies into the game folder.
+use crate::browser::installed::{Entry, Installed};
+use crate::browser::{FileRef, Kind, SourceId, GAME};
+use horizon_world::nbt::{self, Limits, Tag};
+use sha2::Digest;
+use std::fs;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+
+/// The game folder's own files that are the instance's settings.
+pub const FILES: [&str; 6] = [
+    "options.txt",
+    "horizon-graphics.txt",
+    "horizon-extras.txt",
+    "horizon-controller.txt",
+    "horizon-mods.txt",
+    "servers.dat",
+];
+/// Its folders of packs, mods and their settings.
+pub const FOLDERS: [&str; 4] = ["resourcepacks", "shaderpacks", "horizon-mods", "config"];
+/// What a world keeps per player: left out.
+const PER_PLAYER: [&str; 4] = ["playerdata", "stats", "advancements", "session.lock"];
+const INDEX: &str = "modrinth.index.json";
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Format {
+    Mrpack,
+    Zip,
+}
+
+impl Format {
+    pub fn extension(self) -> &'static str {
+        match self {
+            Format::Mrpack => "mrpack",
+            Format::Zip => "zip",
+        }
+    }
+}
+
+/// A file of the instance that its source serves, listed in a `.mrpack` rather than copied.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Linked {
+    /// Relative to the game folder: `resourcepacks/<name>`.
+    pub path: String,
+    pub file: FileRef,
+}
+
+/// What an export wrote.
+#[derive(Debug, PartialEq)]
+pub struct Exported {
+    pub path: PathBuf,
+    /// Files copied in (overrides, for a `.mrpack`).
+    pub copied: usize,
+    /// Files listed by their download.
+    pub linked: usize,
+    /// The worlds in it, by folder.
+    pub worlds: Vec<String>,
+}
+
+/// Writes the instance whose game folder is `home` to `out`. `worlds` are folders of its
+/// `saves/`; `linked` comes from [`linkable`] (empty for a zip).
+pub fn export(
+    home: &Path,
+    name: &str,
+    format: Format,
+    worlds: &[String],
+    linked: &[Linked],
+    out: &Path,
+) -> Result<Exported, String> {
+    let mut files: Vec<(String, PathBuf)> = Vec::new();
+    for f in FILES {
+        if home.join(f).is_file() {
+            files.push((f.to_string(), home.join(f)));
+        }
+    }
+    for folder in FOLDERS {
+        walk(home, &home.join(folder), &[], &mut files);
+    }
+    for world in worlds {
+        let dir = home.join("saves").join(world);
+        if world.contains(['/', '\\']) || !dir.join("level.dat").is_file() {
+            return Err(format!("{name} has no world {world}."));
+        }
+        walk(home, &dir, &PER_PLAYER, &mut files);
+    }
+    let linked: Vec<&Linked> = match format {
+        Format::Mrpack => linked.iter().collect(),
+        Format::Zip => Vec::new(),
+    };
+    files.retain(|(rel, _)| !linked.iter().any(|l| l.path == *rel));
+    if files.is_empty() && linked.is_empty() {
+        return Err(format!(
+            "{name} has nothing to share yet: no settings, packs, mods or worlds."
+        ));
+    }
+    if let Some(dir) = out.parent() {
+        fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    }
+    let part = out.with_extension("part");
+    let written = write(&part, name, format, &files, &linked);
+    let done = written.and_then(|()| fs::rename(&part, out).map_err(|e| e.to_string()));
+    if let Err(e) = done {
+        let _ = fs::remove_file(&part);
+        return Err(format!("Could not export {name}: {e}"));
+    }
+    Ok(Exported {
+        path: out.to_path_buf(),
+        copied: files.len(),
+        linked: linked.len(),
+        worlds: worlds.to_vec(),
+    })
+}
+
+fn write(
+    path: &Path,
+    name: &str,
+    format: Format,
+    files: &[(String, PathBuf)],
+    linked: &[&Linked],
+) -> Result<(), String> {
+    let mut zip = zip::ZipWriter::new(fs::File::create(path).map_err(|e| e.to_string())?);
+    let options = zip::write::SimpleFileOptions::default();
+    let prefix = match format {
+        Format::Mrpack => {
+            zip.start_file(INDEX, options).map_err(|e| e.to_string())?;
+            let index = serde_json::to_vec_pretty(&index(name, linked)).unwrap();
+            zip.write_all(&index).map_err(|e| e.to_string())?;
+            "overrides/"
+        }
+        Format::Zip => "",
+    };
+    for (rel, file) in files {
+        let bytes = match rel.ends_with("/level.dat") {
+            true => shareable_level(file)?,
+            false => fs::read(file).map_err(|e| format!("{}: {e}", file.display()))?,
+        };
+        zip.start_file(format!("{prefix}{rel}"), options)
+            .map_err(|e| e.to_string())?;
+        zip.write_all(&bytes).map_err(|e| e.to_string())?;
+    }
+    zip.finish().map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+/// `modrinth.index.json`: format 1, the files by their downloads, and the Minecraft version.
+fn index(name: &str, linked: &[&Linked]) -> serde_json::Value {
+    let files: Vec<serde_json::Value> = linked
+        .iter()
+        .map(|l| {
+            serde_json::json!({
+                "path": l.path,
+                "hashes": { "sha1": l.file.sha1, "sha512": l.file.sha512 },
+                "env": { "client": "required", "server": "unsupported" },
+                "downloads": [l.file.url],
+                "fileSize": l.file.size,
+            })
+        })
+        .collect();
+    serde_json::json!({
+        "formatVersion": 1,
+        "game": "minecraft",
+        "versionId": "1",
+        "name": name,
+        "summary": format!("{name}, exported from Horizon."),
+        "files": files,
+        "dependencies": { "minecraft": GAME },
+    })
+}
+
+/// Every file under `dir`, relative to `home` with `/`, leaving out the names in `skip` at
+/// `dir`'s top and dot files.
+fn walk(home: &Path, dir: &Path, skip: &[&str], out: &mut Vec<(String, PathBuf)>) {
+    let Ok(entries) = fs::read_dir(dir) else {
+        return;
+    };
+    let mut entries: Vec<_> = entries.flatten().collect();
+    entries.sort_by_key(|e| e.file_name());
+    for e in entries {
+        let name = e.file_name().to_string_lossy().into_owned();
+        if name.starts_with('.') || skip.contains(&name.as_str()) {
+            continue;
+        }
+        let path = e.path();
+        if path.is_dir() {
+            walk(home, &path, &[], out);
+        } else if let Ok(rel) = path.strip_prefix(home) {
+            out.push((rel.to_string_lossy().replace('\\', "/"), path));
+        }
+    }
+}
+
+/// A world's level.dat without the player's UUID; unreadable, it goes as it is.
+fn shareable_level(file: &Path) -> Result<Vec<u8>, String> {
+    let bytes = fs::read(file).map_err(|e| format!("{}: {e}", file.display()))?;
+    let mut raw = Vec::new();
+    if flate2::read::GzDecoder::new(&bytes[..])
+        .take(64 << 20)
+        .read_to_end(&mut raw)
+        .is_err()
+    {
+        return Ok(bytes);
+    }
+    let Ok((mut root, _)) = nbt::read_named(&raw, Limits::default()) else {
+        return Ok(bytes);
+    };
+    if let Some(Tag::Compound(data)) = root.tag.get_mut("Data") {
+        if let Some(Tag::Compound(player)) = data.get_mut(&"Player".into()) {
+            player.remove(&"UUID".into());
+        }
+    }
+    let raw = nbt::write_named(&root, Limits::default()).map_err(|e| e.to_string())?;
+    let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+    gz.write_all(&raw).map_err(|e| e.to_string())?;
+    gz.finish().map_err(|e| e.to_string())
+}
+
+/// The resource packs the browser installed from Modrinth that are still the file it checked:
+/// with `lookup` (the source's file for an entry), what a `.mrpack` can list by download.
+pub fn linkable(home: &Path, lookup: &dyn Fn(&Entry) -> Option<FileRef>) -> Vec<Linked> {
+    Installed::load(home)
+        .entries
+        .iter()
+        .filter(|e| e.source == SourceId::Modrinth && e.kind == Kind::ResourcePack)
+        .filter(|e| {
+            let Ok(bytes) = fs::read(home.join(&e.file)) else {
+                return false;
+            };
+            let sum: String = sha2::Sha512::digest(&bytes)
+                .iter()
+                .map(|b| format!("{b:02x}"))
+                .collect();
+            e.checksum.strip_prefix("SHA-512:") == Some(sum.as_str())
+        })
+        .filter_map(|e| {
+            let file = lookup(e)?;
+            let same = file.sha512.as_deref() == e.checksum.strip_prefix("SHA-512:");
+            (same && file.sha1.is_some()).then(|| Linked {
+                path: e.file.clone(),
+                file,
+            })
+        })
+        .collect()
+}
+
+/// An entry's file as Modrinth serves it (asks Modrinth: for [`linkable`]).
+pub fn from_modrinth(e: &Entry) -> Option<FileRef> {
+    let sum = e.checksum.strip_prefix("SHA-512:")?;
+    crate::browser::modrinth::version_files(&e.version)
+        .ok()?
+        .into_iter()
+        .find(|f| f.sha512.as_deref() == Some(sum))
+}
+
+/// A free path for `name.<extension>` in `dir`: "Name (2).mrpack" when taken.
+pub fn free_path(dir: &Path, name: &str, format: Format) -> PathBuf {
+    let ext = format.extension();
+    let clean: String = name
+        .chars()
+        .map(|c| match c {
+            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '-',
+            c => c,
+        })
+        .collect();
+    (1..)
+        .map(|n| match n {
+            1 => dir.join(format!("{clean}.{ext}")),
+            n => dir.join(format!("{clean} ({n}).{ext}")),
+        })
+        .find(|p| !p.exists())
+        .unwrap()
+}
+
+#[cfg(test)]
+#[path = "export/tests.rs"]
+mod tests;
diff --git a/launcher/src/export/tests.rs b/launcher/src/export/tests.rs
new file mode 100644
index 000000000..d58cb4c4e
--- /dev/null
+++ b/launcher/src/export/tests.rs
@@ -0,0 +1,211 @@
+use super::*;
+use std::collections::BTreeMap;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-export-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+fn put(path: &Path, bytes: &[u8]) {
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(path, bytes).unwrap();
+}
+
+/// A gzipped level.dat whose player has a UUID.
+fn level_dat() -> Vec<u8> {
+    let mut player = BTreeMap::new();
+    player.insert("UUID".into(), Tag::IntArray(vec![1, 2, 3, 4]));
+    player.insert("XpLevel".into(), Tag::Int(7));
+    let mut data = BTreeMap::new();
+    data.insert("LevelName".into(), Tag::String("Base".into()));
+    data.insert("Player".into(), Tag::Compound(player));
+    let mut root = BTreeMap::new();
+    root.insert("Data".into(), Tag::Compound(data));
+    let raw = nbt::write_named(
+        &nbt::NamedTag {
+            name: "".into(),
+            tag: Tag::Compound(root),
+        },
+        Limits::default(),
+    )
+    .unwrap();
+    let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+    gz.write_all(&raw).unwrap();
+    gz.finish().unwrap()
+}
+
+fn sha512(bytes: &[u8]) -> String {
+    sha2::Sha512::digest(bytes)
+        .iter()
+        .map(|b| format!("{b:02x}"))
+        .collect()
+}
+
+/// A game folder with settings, packs, a mod, two worlds, and what never goes out.
+fn home(name: &str) -> PathBuf {
+    let home = scratch(name);
+    put(&home.join("options.txt"), b"lang:fr_ch\n");
+    put(&home.join("horizon-graphics.txt"), b"preset:high\n");
+    put(&home.join("servers.dat"), b"\x0a\x00\x00\x00");
+    put(&home.join("resourcepacks/Glass.zip"), b"glass pack");
+    put(&home.join("resourcepacks/Own.zip"), b"own pack");
+    put(
+        &home.join("horizon-mods/coords/horizon-mod.toml"),
+        b"id = \"coords\"\n",
+    );
+    put(&home.join("saves/Base/level.dat"), &level_dat());
+    put(&home.join("saves/Base/region/r.0.0.mca"), b"region");
+    put(&home.join("saves/Base/playerdata/0001.dat"), b"me");
+    put(&home.join("saves/Base/stats/0001.json"), b"{}");
+    put(&home.join("saves/Base/session.lock"), b"");
+    put(&home.join("saves/Other/level.dat"), &level_dat());
+    for private in [
+        "logs/latest.log",
+        "screenshots/a.png",
+        "backups/b.zip",
+        "mod-browser/checks-1/x/check.json",
+        "horizon-player.txt",
+        "session.json",
+        "usercache.json",
+        "resourcepacks/.DS_Store",
+    ] {
+        put(&home.join(private), b"private");
+    }
+    let entry = serde_json::json!({ "entries": [{
+        "source": "modrinth", "project": "P1", "slug": "glass", "title": "Glass",
+        "kind": "resource-pack", "version": "V1", "number": "1.0",
+        "file": "resourcepacks/Glass.zip",
+        "checksum": format!("SHA-512:{}", sha512(b"glass pack")),
+        "page": "https://modrinth.com/resourcepack/glass",
+    }]});
+    put(
+        &home.join("mod-browser.json"),
+        &serde_json::to_vec(&entry).unwrap(),
+    );
+    home
+}
+
+fn names(zip: &Path) -> Vec<String> {
+    let zip = zip::ZipArchive::new(fs::File::open(zip).unwrap()).unwrap();
+    let mut names: Vec<String> = zip.file_names().map(str::to_string).collect();
+    names.sort();
+    names
+}
+
+fn read(zip: &Path, name: &str) -> Vec<u8> {
+    let mut zip = zip::ZipArchive::new(fs::File::open(zip).unwrap()).unwrap();
+    let mut out = Vec::new();
+    zip.by_name(name).unwrap().read_to_end(&mut out).unwrap();
+    out
+}
+
+fn served(e: &Entry) -> Option<FileRef> {
+    (e.version == "V1").then(|| FileRef {
+        url: "https://cdn.modrinth.com/data/P1/versions/V1/Glass.zip".into(),
+        name: "Glass.zip".into(),
+        size: 10,
+        sha512: Some(sha512(b"glass pack")),
+        sha256: None,
+        sha1: Some("ab".repeat(20)),
+        primary: true,
+    })
+}
+
+#[test]
+fn a_zip_has_the_instance_and_the_picked_world_and_nothing_private() {
+    let home = home("zip");
+    let out = home.join("out/Hardcore.zip");
+    let done = export(&home, "Hardcore", Format::Zip, &["Base".into()], &[], &out).unwrap();
+    assert_eq!((done.copied, done.linked), (8, 0));
+    // Settings, packs, the mod and the picked world, without its per-player files; no logs,
+    // screenshots, backups, caches, account files or the other world.
+    assert_eq!(
+        names(&out),
+        [
+            "horizon-graphics.txt",
+            "horizon-mods/coords/horizon-mod.toml",
+            "options.txt",
+            "resourcepacks/Glass.zip",
+            "resourcepacks/Own.zip",
+            "saves/Base/level.dat",
+            "saves/Base/region/r.0.0.mca",
+            "servers.dat",
+        ]
+    );
+    // The world's level.dat keeps the player, without the UUID.
+    let mut raw = Vec::new();
+    flate2::read::GzDecoder::new(&read(&out, "saves/Base/level.dat")[..])
+        .read_to_end(&mut raw)
+        .unwrap();
+    let (root, _) = nbt::read_named(&raw, Limits::default()).unwrap();
+    let Some(Tag::Compound(data)) = root.tag.get("Data") else {
+        panic!("no Data")
+    };
+    let Some(Tag::Compound(player)) = data.get(&"Player".into()) else {
+        panic!("no Player")
+    };
+    assert!(player.get(&"UUID".into()).is_none());
+    assert_eq!(player.get(&"XpLevel".into()), Some(&Tag::Int(7)));
+    assert!(!out.with_extension("part").exists());
+
+    assert!(export(&home, "Hardcore", Format::Zip, &["../x".into()], &[], &out).is_err());
+    let empty = scratch("empty");
+    let refused = export(&empty, "New", Format::Zip, &[], &[], &empty.join("New.zip"));
+    assert_eq!(
+        refused.unwrap_err(),
+        "New has nothing to share yet: no settings, packs, mods or worlds."
+    );
+    assert!(!empty.join("New.zip").exists());
+    fs::remove_dir_all(&empty).unwrap();
+    fs::remove_dir_all(&home).unwrap();
+}
+
+#[test]
+fn an_mrpack_lists_what_modrinth_serves_and_carries_the_rest() {
+    let home = home("mrpack");
+    let linked = linkable(&home, &served);
+    assert_eq!(linked.len(), 1);
+    let out = free_path(&home, "Hard: core", Format::Mrpack);
+    assert_eq!(out.file_name().unwrap(), "Hard- core.mrpack");
+    let done = export(&home, "Hardcore", Format::Mrpack, &[], &linked, &out).unwrap();
+    assert_eq!((done.copied, done.linked), (5, 1));
+    assert_eq!(
+        names(&out),
+        [
+            "modrinth.index.json",
+            "overrides/horizon-graphics.txt",
+            "overrides/horizon-mods/coords/horizon-mod.toml",
+            "overrides/options.txt",
+            "overrides/resourcepacks/Own.zip",
+            "overrides/servers.dat",
+        ]
+    );
+    let index: serde_json::Value =
+        serde_json::from_slice(&read(&out, "modrinth.index.json")).unwrap();
+    assert_eq!(index["formatVersion"], 1);
+    assert_eq!(index["game"], "minecraft");
+    assert_eq!(index["dependencies"]["minecraft"], GAME);
+    let file = &index["files"][0];
+    assert_eq!(file["path"], "resourcepacks/Glass.zip");
+    assert_eq!(
+        file["downloads"][0],
+        "https://cdn.modrinth.com/data/P1/versions/V1/Glass.zip"
+    );
+    assert_eq!(file["hashes"]["sha512"], sha512(b"glass pack"));
+    assert_eq!(
+        free_path(&home, "Hard: core", Format::Mrpack)
+            .file_name()
+            .unwrap(),
+        "Hard- core (2).mrpack"
+    );
+
+    // A pack changed since its install is carried, not linked.
+    put(&home.join("resourcepacks/Glass.zip"), b"edited");
+    assert!(linkable(&home, &served).is_empty());
+    fs::remove_dir_all(&home).unwrap();
+}
diff --git a/launcher/src/export_page.rs b/launcher/src/export_page.rs
new file mode 100644
index 000000000..d21a60d46
--- /dev/null
+++ b/launcher/src/export_page.rs
@@ -0,0 +1,213 @@
+//! Export… on Home's Instance row: the selected instance as a `.mrpack` or a `.zip`, with the
+//! worlds the player switches on, written to the launcher's `exports/` folder
+//! (`horizon_launcher::export`).
+use super::*;
+use horizon_launcher::export::{self, Format};
+use std::path::PathBuf;
+
+pub(super) struct ExportPanel {
+    /// The instance it is for: picking another closes it.
+    instance: String,
+    format: Format,
+    /// The instance's worlds (folder, name) and whether each goes in.
+    worlds: Vec<(String, String, bool)>,
+    busy: bool,
+    /// The file written, or why not.
+    done: Option<Result<(String, PathBuf), String>>,
+}
+
+impl Launcher {
+    pub(super) fn toggle_export(&mut self) {
+        if self.export.take().is_some() {
+            return;
+        }
+        let Some(i) = self.selected_instance() else {
+            return;
+        };
+        let worlds = horizon_launcher::worlds::list(&i.home)
+            .into_iter()
+            .map(|w| (w.folder, w.name, false))
+            .collect();
+        self.export = Some(ExportPanel {
+            instance: i.id.clone(),
+            format: Format::Mrpack,
+            worlds,
+            busy: false,
+            done: None,
+        });
+    }
+
+    fn run_export(&mut self, cx: &mut Context<Self>) {
+        let Some(i) = self.selected_instance().cloned() else {
+            return;
+        };
+        let Some(panel) = self.export.as_mut().filter(|p| !p.busy) else {
+            return;
+        };
+        panel.busy = true;
+        panel.done = None;
+        let format = panel.format;
+        let worlds: Vec<String> = panel
+            .worlds
+            .iter()
+            .filter(|w| w.2)
+            .map(|w| w.0.clone())
+            .collect();
+        let task = cx.background_executor().spawn(async move {
+            let linked = match format {
+                Format::Mrpack => export::linkable(&i.home, &export::from_modrinth),
+                Format::Zip => Vec::new(),
+            };
+            let out = export::free_path(&backend::data_dir().join("exports"), &i.name, format);
+            export::export(&i.home, &i.name, format, &worlds, &linked, &out).map(|done| {
+                let linked = match done.linked {
+                    0 => String::new(),
+                    n => format!(", {n} listed by their Modrinth download"),
+                };
+                let file = done.path.file_name().unwrap_or_default().to_string_lossy();
+                (
+                    format!("Exported {file}: {} files{linked}.", done.copied),
+                    done.path,
+                )
+            })
+        });
+        cx.spawn(async move |this, cx| {
+            let done = task.await;
+            let _ = this.update(cx, |this, cx| {
+                if let Some(panel) = &mut this.export {
+                    panel.busy = false;
+                    panel.done = Some(done);
+                }
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    /// The panel under the Instance row, while it is open.
+    pub(super) fn export_panel(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let selected = self.selected_instance()?.id.clone();
+        if self.export.as_ref()?.instance != selected {
+            self.export = None;
+            return None;
+        }
+        let panel = self.export.as_ref()?;
+        let formats = [(Format::Mrpack, ".mrpack"), (Format::Zip, ".zip")];
+        let mut pick = div().flex().items_center().gap(px(6.));
+        for (format, label) in formats {
+            let on = panel.format == format;
+            pick = pick.child(
+                button(
+                    SharedString::from(format!("export-{}", format.extension())),
+                    label,
+                    if on { Kind::Secondary } else { Kind::Ghost },
+                    &t,
+                )
+                .when(on, |b| b.border_color(t.accent))
+                .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                    if let Some(p) = &mut this.export {
+                        p.format = format;
+                    }
+                    cx.notify();
+                })),
+            );
+        }
+        let about = match panel.format {
+            Format::Mrpack => {
+                "Modrinth's modpack format: resource packs from Modrinth are listed by their \
+                 download, the rest is carried in it."
+            }
+            Format::Zip => "The game folder's own layout, zipped.",
+        };
+        let mut worlds = div().flex().flex_col().gap(px(6.));
+        if panel.worlds.is_empty() {
+            worlds = worlds.child(
+                text(theme::CAPTION)
+                    .text_color(t.muted)
+                    .child("No worlds to put in."),
+            );
+        }
+        for (n, (_, name, on)) in panel.worlds.iter().enumerate() {
+            worlds = worlds.child(
+                div()
+                    .id(SharedString::from(format!("export-world-{n}")))
+                    .flex()
+                    .items_center()
+                    .gap(px(10.))
+                    .cursor_pointer()
+                    .child(switch(
+                        SharedString::from(format!("export-world-switch-{n}")),
+                        *on,
+                        &t,
+                    ))
+                    .child(
+                        text(theme::LABEL)
+                            .text_color(t.ink_soft)
+                            .child(name.clone()),
+                    )
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        if let Some(w) = this.export.as_mut().and_then(|p| p.worlds.get_mut(n)) {
+                            w.2 = !w.2;
+                        }
+                        cx.notify();
+                    })),
+            );
+        }
+        let go = button("export-run", "Export", Kind::Secondary, &t);
+        let go = match panel.busy {
+            true => disabled(go),
+            false => go.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                this.run_export(cx);
+                cx.notify();
+            })),
+        };
+        let result = match &panel.done {
+            Some(Ok((said, path))) => {
+                let path = path.clone();
+                Some(
+                    div()
+                        .flex()
+                        .items_center()
+                        .gap(px(10.))
+                        .child(text(theme::CAPTION).text_color(t.muted).child(said.clone()))
+                        .child(
+                            button("export-show", "Show in folder", Kind::Ghost, &t)
+                                .on_click(move |_, _, cx| cx.reveal_path(&path)),
+                        ),
+                )
+            }
+            Some(Err(e)) => Some(div().child(notice(e.clone(), &t))),
+            None => None,
+        };
+        Some(
+            plate(&t)
+                .flex()
+                .flex_col()
+                .gap(px(12.))
+                .px(px(14.))
+                .py(px(12.))
+                .ml(px(40.))
+                .child(caps("Export to share").text_color(t.muted))
+                .child(pick)
+                .child(text(theme::CAPTION).text_color(t.muted).child(about))
+                .child(caps("Worlds").text_color(t.muted))
+                .child(worlds)
+                .child(text(theme::CAPTION).text_color(t.muted).child(
+                    "Settings, packs and Horizon mods go in; logs, screenshots, backups and \
+                         your account never do. Worlds go without their per-player files.",
+                ))
+                .child(
+                    div()
+                        .flex()
+                        .items_center()
+                        .gap(px(10.))
+                        .child(go)
+                        .when(panel.busy, |d| {
+                            d.child(text(theme::CAPTION).text_color(t.muted).child("Exporting…"))
+                        }),
+                )
+                .children(result),
+        )
+    }
+}
diff --git a/launcher/src/game_log.rs b/launcher/src/game_log.rs
new file mode 100644
index 000000000..1d671f27e
--- /dev/null
+++ b/launcher/src/game_log.rs
@@ -0,0 +1,159 @@
+//! The game's log as the console shows it, and sharing it.
+//!
+//! Sharing uploads the log to mclo.gs, and only when the player asks (a click, or `logs share`).
+//! mclo.gs is a paste service made for Minecraft logs by Aternos: no account, links expire after
+//! 90 days unread, and the uploader gets a token that deletes the paste. Before anything leaves
+//! the computer, [`private`] takes out the player's home folder, their user name and their
+//! account names.
+use std::path::Path;
+
+/// mclo.gs's API; `HORIZON_LAUNCHER_PASTE_URL` points it elsewhere for tests.
+const API: &str = "https://api.mclo.gs/1";
+const PASTE_ENV: &str = "HORIZON_LAUNCHER_PASTE_URL";
+/// mclo.gs keeps at most 25,000 lines and 10 MiB: the end of a longer log is sent.
+const MAX_LINES: usize = 25_000;
+const MAX_BYTES: usize = 10 << 20;
+
+fn api() -> String {
+    std::env::var(PASTE_ENV)
+        .ok()
+        .filter(|u| !u.is_empty())
+        .unwrap_or_else(|| API.into())
+}
+
+/// Whether a console line matches the search: every word, in any case.
+pub fn matches(line: &str, search: &str) -> bool {
+    let line = line.to_lowercase();
+    search
+        .split_whitespace()
+        .all(|w| line.contains(&w.to_lowercase()))
+}
+
+/// The names to take out of a log: the account names and offline names, the offline player
+/// name kept in each game folder (`horizon-player.txt`), and the computer's user name.
+pub fn names(homes: &[&Path]) -> Vec<String> {
+    let accounts = crate::account::Accounts::load();
+    let mut names: Vec<String> = accounts.accounts.into_iter().map(|a| a.name).collect();
+    names.extend(accounts.offline);
+    for home in homes {
+        if let Ok(name) = std::fs::read_to_string(home.join("horizon-player.txt")) {
+            names.push(name.trim().to_string());
+        }
+    }
+    for var in ["USER", "USERNAME"] {
+        if let Ok(user) = std::env::var(var) {
+            names.push(user);
+        }
+    }
+    if let Some(user) =
+        dirs::home_dir().and_then(|h| h.file_name().map(|n| n.to_string_lossy().into_owned()))
+    {
+        names.push(user);
+    }
+    names.retain(|n| n.chars().count() >= 3);
+    names.sort_by_key(|n| std::cmp::Reverse(n.len()));
+    names.dedup();
+    names
+}
+
+/// The log without the home folder (`~` instead, with either slash) and without `names` (each
+/// becomes `<player>`), as whole words in any case.
+pub fn private(text: &str, home: Option<&Path>, names: &[String]) -> String {
+    let mut out = text.to_string();
+    if let Some(home) = home
+        .map(|h| h.to_string_lossy().into_owned())
+        .filter(|h| h.len() > 1)
+    {
+        out = out.replace(&home, "~");
+        out = out.replace(&home.replace('\\', "/"), "~");
+        out = out.replace(&home.replace('/', "\\"), "~");
+    }
+    for name in names {
+        out = replace_word(&out, name, "<player>");
+    }
+    out
+}
+
+/// Replaces `word` (any case) where it isn't part of a longer name.
+fn replace_word(text: &str, word: &str, with: &str) -> String {
+    let lower = text.to_lowercase();
+    let find = word.to_lowercase();
+    if find.is_empty() || lower.len() != text.len() {
+        // A case change that moves bytes (rare scripts): exact matches only.
+        return text.replace(word, with);
+    }
+    let part = |c: Option<char>| c.is_some_and(|c| c.is_alphanumeric() || c == '_');
+    let mut out = String::with_capacity(text.len());
+    let mut at = 0;
+    while let Some(i) = lower[at..].find(&find).map(|i| i + at) {
+        let end = i + find.len();
+        if part(text[..i].chars().next_back()) || part(text[end..].chars().next()) {
+            out.push_str(&text[at..end]);
+        } else {
+            out.push_str(&text[at..i]);
+            out.push_str(with);
+        }
+        at = end;
+    }
+    out.push_str(&text[at..]);
+    out
+}
+
+/// The end of the log that fits what mclo.gs keeps.
+pub fn fit(text: &str) -> &str {
+    let mut start = 0;
+    let lines: Vec<usize> = text.match_indices('\n').map(|(i, _)| i + 1).collect();
+    if lines.len() > MAX_LINES {
+        start = lines[lines.len() - MAX_LINES - 1];
+    }
+    while text.len() - start > MAX_BYTES {
+        start = text[start..]
+            .find('\n')
+            .map_or(text.len(), |i| start + i + 1);
+    }
+    &text[start..]
+}
+
+/// A shared log: its page, and what deletes it.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Shared {
+    pub url: String,
+    pub id: String,
+    pub token: String,
+}
+
+/// Uploads `text` (already [`private`]) and returns its link.
+pub fn share(text: &str) -> Result<Shared, String> {
+    let body = serde_json::json!({ "content": fit(text), "source": "Horizon launcher" });
+    let answer: serde_json::Value = ureq::post(&format!("{}/log", api()))
+        .send_json(body)
+        .map_err(|e| format!("mclo.gs didn't take the log: {e}"))?
+        .into_json()
+        .map_err(|e| format!("mclo.gs answered something unexpected: {e}"))?;
+    let field = |k: &str| answer[k].as_str().map(str::to_string);
+    match (
+        answer["success"].as_bool(),
+        field("url"),
+        field("id"),
+        field("token"),
+    ) {
+        (Some(true), Some(url), Some(id), Some(token)) => Ok(Shared { url, id, token }),
+        _ => Err(format!(
+            "mclo.gs didn't take the log: {}",
+            field("error").unwrap_or_else(|| "no reason given".into())
+        )),
+    }
+}
+
+/// Deletes a log shared from here.
+pub fn unshare(shared: &Shared) -> Result<(), String> {
+    ureq::delete(&format!("{}/log/{}", api(), shared.id))
+        .set("Authorization", &format!("Bearer {}", shared.token))
+        .call()
+        .map_err(|e| format!("mclo.gs didn't delete it: {e}"))?;
+    Ok(())
+}
+
+#[cfg(test)]
+#[path = "game_log/tests.rs"]
+mod tests;
diff --git a/launcher/src/game_log/tests.rs b/launcher/src/game_log/tests.rs
new file mode 100644
index 000000000..b353df173
--- /dev/null
+++ b/launcher/src/game_log/tests.rs
@@ -0,0 +1,114 @@
+use super::*;
+use std::io::{BufRead, BufReader, Read, Write};
+
+#[test]
+fn search_matches_every_word_in_any_case() {
+    assert!(matches(
+        "[12:00:01] [Render thread/WARN]: Missing texture",
+        "warn texture"
+    ));
+    assert!(!matches("[12:00:01] [Render thread/INFO]: Loaded", "warn"));
+    assert!(matches("anything", "  "));
+}
+
+#[test]
+fn the_shared_log_has_no_home_folder_or_names() {
+    let log = "Loading /Users/ludovicmarie/Library/Application Support/horizon/options.txt\n\
+               C:\\Users\\ludovicmarie\\AppData\\horizon too\n\
+               Ludo47 joined the game\n\
+               <ludo47> hi, Ludo470 is someone else\n\
+               user LUDOVICMARIE on ludovicmarie-mac\n";
+    let names = vec!["ludovicmarie".to_string(), "Ludo47".to_string()];
+    let out = private(log, Some(Path::new("/Users/ludovicmarie")), &names);
+    assert_eq!(
+        out,
+        "Loading ~/Library/Application Support/horizon/options.txt\n\
+         C:~\\AppData\\horizon too\n\
+         <player> joined the game\n\
+         <<player>> hi, Ludo470 is someone else\n\
+         user <player> on <player>-mac\n"
+    );
+}
+
+#[test]
+fn a_long_log_sends_its_end() {
+    let log: String = (0..30_000).map(|i| format!("line {i}\n")).collect();
+    let sent = fit(&log);
+    assert_eq!(sent.lines().count(), MAX_LINES);
+    assert!(sent.starts_with("line 5000\n") && sent.ends_with("line 29999\n"));
+    assert_eq!(fit("short\n"), "short\n");
+}
+
+/// A one-request HTTP server that answers `body` and hands back what it was sent.
+fn stub(body: &'static str) -> (String, std::thread::JoinHandle<String>) {
+    let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+    let url = format!("http://{}", listener.local_addr().unwrap());
+    let served = std::thread::spawn(move || {
+        let (stream, _) = listener.accept().unwrap();
+        let mut reader = BufReader::new(stream);
+        let mut head = String::new();
+        let mut length = 0;
+        loop {
+            let mut line = String::new();
+            reader.read_line(&mut line).unwrap();
+            if let Some(n) = line.to_ascii_lowercase().strip_prefix("content-length:") {
+                length = n.trim().parse().unwrap();
+            }
+            head.push_str(&line);
+            if line == "\r\n" {
+                break;
+            }
+        }
+        let mut sent = vec![0; length];
+        reader.read_exact(&mut sent).unwrap();
+        let reply = format!(
+            "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{body}",
+            body.len()
+        );
+        reader.get_mut().write_all(reply.as_bytes()).unwrap();
+        head + &String::from_utf8(sent).unwrap()
+    });
+    (url, served)
+}
+
+#[test]
+fn shares_and_deletes_through_the_paste_api() {
+    let (url, served) =
+        stub(r#"{"success":true,"id":"Ab12","url":"https://mclo.gs/Ab12","token":"t0k"}"#);
+    std::env::set_var(PASTE_ENV, &url);
+    let shared = share("[main/INFO]: hello\n").unwrap();
+    assert_eq!(
+        shared,
+        Shared {
+            url: "https://mclo.gs/Ab12".into(),
+            id: "Ab12".into(),
+            token: "t0k".into()
+        }
+    );
+    let request = served.join().unwrap();
+    assert!(request.starts_with("POST /log "), "{request}");
+    assert!(
+        request.ends_with(r#"{"content":"[main/INFO]: hello\n","source":"Horizon launcher"}"#),
+        "{request}"
+    );
+
+    let (url, served) = stub(r#"{"success":true}"#);
+    std::env::set_var(PASTE_ENV, &url);
+    unshare(&shared).unwrap();
+    let request = served.join().unwrap();
+    assert!(request.starts_with("DELETE /log/Ab12 "), "{request}");
+    assert!(
+        request
+            .to_ascii_lowercase()
+            .contains("authorization: bearer t0k"),
+        "{request}"
+    );
+
+    let (url, _served) = stub(r#"{"success":false,"error":"Required field 'content' not found."}"#);
+    std::env::set_var(PASTE_ENV, &url);
+    assert_eq!(
+        share("").unwrap_err(),
+        "mclo.gs didn't take the log: Required field 'content' not found."
+    );
+    std::env::remove_var(PASTE_ENV);
+}
diff --git a/launcher/src/i18n.rs b/launcher/src/i18n.rs
new file mode 100644
index 000000000..7635461d5
--- /dev/null
+++ b/launcher/src/i18n.rs
@@ -0,0 +1,134 @@
+//! The launcher's languages: English (the strings in the code), French and Russian, the
+//! languages Horizon's own game menus have. A table per language (`launcher/lang/<code>.json`)
+//! maps each English string to its translation; a string the table lacks shows in English.
+//!
+//! The language follows the system's unless the player picks one in Settings
+//! (`Settings::language`). Translations are Horizon's own, written for this launcher.
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicU8, Ordering};
+use std::sync::OnceLock;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Language {
+    #[default]
+    #[serde(rename = "en")]
+    English,
+    #[serde(rename = "fr")]
+    French,
+    #[serde(rename = "ru")]
+    Russian,
+}
+
+impl Language {
+    pub const ALL: [Language; 3] = [Self::English, Self::French, Self::Russian];
+
+    /// Its code in `settings.json` and on the command line.
+    pub fn code(self) -> &'static str {
+        match self {
+            Self::English => "en",
+            Self::French => "fr",
+            Self::Russian => "ru",
+        }
+    }
+
+    /// Its name in itself: what a player looks for in a list of languages.
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::English => "English",
+            Self::French => "Français",
+            Self::Russian => "Русский",
+        }
+    }
+
+    /// A language code (`fr`, `fr-CH`, `fr_FR.UTF-8`), if the launcher has it.
+    pub fn parse(code: &str) -> Option<Self> {
+        let lower = code.trim().to_ascii_lowercase();
+        let base = lower.split(['-', '_', '.', '@']).next().unwrap_or("");
+        Self::ALL.into_iter().find(|l| l.code() == base)
+    }
+
+    /// The first of the system's preferred languages the launcher has, else English.
+    pub fn pick<'a>(preferred: impl IntoIterator<Item = &'a str>) -> Self {
+        preferred
+            .into_iter()
+            .find_map(Self::parse)
+            .unwrap_or_default()
+    }
+
+    /// The system's language, as far as the launcher has it.
+    pub fn system() -> Self {
+        let locales: Vec<String> = sys_locale::get_locales().collect();
+        Self::pick(locales.iter().map(String::as_str))
+    }
+
+    /// The table, as shipped: English text to this language's.
+    fn source(self) -> &'static str {
+        match self {
+            Self::English => "{}",
+            Self::French => include_str!("../lang/fr.json"),
+            Self::Russian => include_str!("../lang/ru.json"),
+        }
+    }
+}
+
+static CURRENT: AtomicU8 = AtomicU8::new(0);
+
+/// Shows the launcher in `language` from now on.
+pub fn set(language: Language) {
+    let i = Language::ALL
+        .iter()
+        .position(|l| *l == language)
+        .unwrap_or(0);
+    CURRENT.store(i as u8, Ordering::Relaxed);
+}
+
+pub fn current() -> Language {
+    Language::ALL[CURRENT.load(Ordering::Relaxed) as usize % Language::ALL.len()]
+}
+
+type Table = HashMap<String, &'static str>;
+
+fn table(language: Language) -> &'static Table {
+    static TABLES: OnceLock<Vec<Table>> = OnceLock::new();
+    let tables = TABLES.get_or_init(|| {
+        Language::ALL
+            .iter()
+            .map(|l| {
+                serde_json::from_str::<HashMap<String, String>>(l.source())
+                    .unwrap_or_default()
+                    .into_iter()
+                    .map(|(en, said)| (en, &*Box::leak(said.into_boxed_str())))
+                    .collect()
+            })
+            .collect()
+    });
+    let i = Language::ALL
+        .iter()
+        .position(|l| *l == language)
+        .unwrap_or(0);
+    &tables[i]
+}
+
+/// `en` in `language`, or `en` itself where the table lacks it.
+pub fn tr_in(language: Language, en: &str) -> &str {
+    table(language).get(en).copied().unwrap_or(en)
+}
+
+/// `en` in the launcher's language.
+pub fn tr(en: &str) -> &str {
+    tr_in(current(), en)
+}
+
+/// `en` in the launcher's language with its `{name}` holes filled.
+pub fn trf(en: &str, args: &[(&str, &str)]) -> String {
+    let mut out = tr(en).to_string();
+    for (name, value) in args {
+        out = out.replace(&format!("{{{name}}}"), value);
+    }
+    out
+}
+
+#[cfg(test)]
+#[path = "i18n/tests.rs"]
+mod tests;
diff --git a/launcher/src/i18n/tests.rs b/launcher/src/i18n/tests.rs
new file mode 100644
index 000000000..b9674f976
--- /dev/null
+++ b/launcher/src/i18n/tests.rs
@@ -0,0 +1,135 @@
+use super::*;
+use std::collections::BTreeSet;
+use std::path::Path;
+
+/// Every Rust file of the launcher's sources.
+fn sources(dir: &Path, out: &mut Vec<String>) {
+    for entry in std::fs::read_dir(dir).unwrap().flatten() {
+        let path = entry.path();
+        if path.is_dir() {
+            sources(&path, out);
+        } else if path.extension().is_some_and(|e| e == "rs") {
+            // Comments left out: they quote strings too.
+            let code = std::fs::read_to_string(path).unwrap();
+            let lines = code
+                .lines()
+                .map(|l| match l.trim_start().starts_with("//") {
+                    true => "",
+                    false => l,
+                });
+            out.push(lines.collect::<Vec<_>>().join("\n"));
+        }
+    }
+}
+
+/// The string literal at the start of `code` (just after its opening quote), unescaped the way
+/// Rust does: `\"`, `\\`, `\n`, and a backslash at a line's end that drops the next line's
+/// indent.
+fn literal(code: &str) -> String {
+    let mut out = String::new();
+    let mut chars = code.chars().peekable();
+    while let Some(c) = chars.next() {
+        match c {
+            '"' => break,
+            '\\' => match chars.next() {
+                Some('n') => out.push('\n'),
+                Some('\n') => {
+                    while chars.peek().is_some_and(|c| c.is_whitespace()) {
+                        chars.next();
+                    }
+                }
+                Some(c) => out.push(c),
+                None => break,
+            },
+            c => out.push(c),
+        }
+    }
+    out
+}
+
+/// The English strings the code asks a translation for: `tr("…")` and `trf("…")`, and every
+/// other string literal (some reach `tr` through a widget).
+fn strings() -> (BTreeSet<String>, BTreeSet<String>) {
+    let mut files = Vec::new();
+    sources(
+        &Path::new(env!("CARGO_MANIFEST_DIR")).join("src"),
+        &mut files,
+    );
+    let (mut asked, mut all) = (BTreeSet::new(), BTreeSet::new());
+    for file in &files {
+        for (at, _) in file.match_indices('"') {
+            let before = &file[..at];
+            if before.ends_with('\\') || before.ends_with('\'') {
+                continue;
+            }
+            let s = literal(&file[at + 1..]);
+            let call = |name: &str| {
+                before.ends_with(&format!("{name}(")) && {
+                    let head = &before[..before.len() - name.len() - 1];
+                    !head.ends_with(|c: char| c.is_alphanumeric() || c == '_')
+                }
+            };
+            if call("tr") || call("trf") {
+                asked.insert(s.clone());
+            }
+            all.insert(s);
+        }
+    }
+    (asked, all)
+}
+
+fn holes(s: &str) -> BTreeSet<&str> {
+    s.split('{')
+        .skip(1)
+        .filter_map(|part| part.split_once('}').map(|(name, _)| name))
+        .collect()
+}
+
+#[test]
+fn every_language_has_every_string_the_code_asks_for() {
+    let (asked, all) = strings();
+    assert!(asked.contains("Language"), "the scan finds tr(\"…\")");
+    for language in [Language::French, Language::Russian] {
+        let table: HashMap<String, String> = serde_json::from_str(language.source())
+            .unwrap_or_else(|e| panic!("lang/{}.json: {e}", language.code()));
+        let missing: Vec<_> = asked.iter().filter(|s| !table.contains_key(*s)).collect();
+        assert!(
+            missing.is_empty(),
+            "lang/{}.json lacks {missing:#?}",
+            language.code()
+        );
+        let unused: Vec<_> = table.keys().filter(|s| !all.contains(*s)).collect();
+        assert!(
+            unused.is_empty(),
+            "lang/{}.json has strings the code no longer has: {unused:#?}",
+            language.code()
+        );
+        for (en, said) in &table {
+            assert_eq!(holes(en), holes(said), "{}: {en:?}", language.code());
+            assert!(
+                !said.trim().is_empty(),
+                "{}: {en:?} is empty",
+                language.code()
+            );
+        }
+    }
+}
+
+#[test]
+fn the_system_language_is_the_first_one_the_launcher_has() {
+    assert_eq!(Language::pick(["fr-CH", "en-US"]), Language::French);
+    assert_eq!(Language::pick(["de-CH", "ru_RU.UTF-8"]), Language::Russian);
+    assert_eq!(Language::pick(["de-DE", "ja"]), Language::English);
+    assert_eq!(Language::pick([]), Language::English);
+    assert_eq!(Language::parse("FR"), Some(Language::French));
+    assert_eq!(Language::parse("french"), None);
+    assert_eq!(serde_json::to_string(&Language::Russian).unwrap(), "\"ru\"");
+}
+
+#[test]
+fn a_missing_string_shows_in_english() {
+    assert_eq!(tr_in(Language::French, "Settings"), "Paramètres");
+    assert_eq!(tr_in(Language::Russian, "Settings"), "Настройки");
+    assert_eq!(tr_in(Language::English, "Settings"), "Settings");
+    assert_eq!(tr_in(Language::French, "No such string"), "No such string");
+}
diff --git a/launcher/src/import.rs b/launcher/src/import.rs
new file mode 100644
index 000000000..1d8625748
--- /dev/null
+++ b/launcher/src/import.rs
@@ -0,0 +1,232 @@
+//! A file dropped on the window (or given to `instance import`): what it is, and an instance
+//! made from a shared one.
+//!
+//! - A `.mrpack` that needs no mod loader (only `minecraft` in its dependencies), such as
+//!   [`crate::export`] writes, or a `.zip` laid out as a game folder: a new instance. Its
+//!   `overrides/` (and `client-overrides/`) go into the instance's folder; each of its `files`
+//!   is downloaded from Modrinth and checked against its SHA-512 (`browser::download`).
+//! - A `.mrpack` for a mod loader, or a CurseForge modpack zip (`manifest.json`): a Java
+//!   modpack, for the Modpacks import (`modpacks::import`).
+//! - A zip with `pack.mcmeta`: a data pack (`data/`) or a resource pack; with `shaders/`, or a
+//!   `.hshader`: a shader pack.
+//!
+//! Only what an instance holds is taken from a shared zip ([`crate::export::FILES`],
+//! [`crate::export::FOLDERS`], `saves/`), and every path is checked to stay inside its folder.
+use crate::browser::{download, FileRef};
+use crate::export::{FILES, FOLDERS};
+use crate::instances::{self, Instance};
+use crate::packs;
+use std::fs;
+use std::io::Read;
+use std::path::{Component, Path, PathBuf};
+
+const INDEX: &str = "modrinth.index.json";
+/// The `.mrpack` folders copied into the game folder; `server-overrides/` is a server's.
+const OVERRIDES: [&str; 2] = ["overrides/", "client-overrides/"];
+
+/// What a dropped file is.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Dropped {
+    /// A shared instance: a new instance is made from it.
+    Instance,
+    /// A Java modpack, for the Modpacks import.
+    Modpack,
+    /// A resource or shader pack, for the selected instance.
+    Pack(packs::Kind),
+    /// A data pack: it goes into a world.
+    DataPack,
+}
+
+fn open(file: &Path) -> Result<zip::ZipArchive<fs::File>, String> {
+    fs::File::open(file)
+        .ok()
+        .and_then(|f| zip::ZipArchive::new(f).ok())
+        .ok_or_else(|| format!("{} is not a zip file that can be read.", name_of(file)))
+}
+
+fn name_of(file: &Path) -> String {
+    file.file_name()
+        .map(|n| n.to_string_lossy().into_owned())
+        .unwrap_or_default()
+}
+
+fn read_index(zip: &mut zip::ZipArchive<fs::File>) -> Result<serde_json::Value, String> {
+    let mut text = Vec::new();
+    zip.by_name(INDEX)
+        .map_err(|_| format!("It has no {INDEX}: not a .mrpack."))?
+        .take(16 << 20)
+        .read_to_end(&mut text)
+        .map_err(|e| e.to_string())?;
+    serde_json::from_slice(&text).map_err(|e| format!("{INDEX}: {e}"))
+}
+
+/// What `file` is, from its name and what is inside.
+pub fn what(file: &Path) -> Result<Dropped, String> {
+    let name = name_of(file);
+    let ext = file
+        .extension()
+        .map(|e| e.to_string_lossy().to_ascii_lowercase());
+    match ext.as_deref() {
+        Some("hshader") => return Ok(Dropped::Pack(packs::Kind::Shader)),
+        Some("mrpack") => {
+            let index = read_index(&mut open(file)?)?;
+            let loaders = index["dependencies"]
+                .as_object()
+                .is_some_and(|d| d.keys().any(|k| k != "minecraft"));
+            return Ok(match loaders {
+                true => Dropped::Modpack,
+                false => Dropped::Instance,
+            });
+        }
+        Some("zip") => {}
+        _ => {
+            return Err(format!(
+                "{name} can't be imported: drop a .mrpack, a .zip or a .hshader."
+            ))
+        }
+    }
+    let zip = open(file)?;
+    let has = |n: &str| zip.index_for_name(n).is_some();
+    let under = |p: &str| zip.file_names().any(|n| n.starts_with(p));
+    if has("manifest.json") && !has("pack.mcmeta") {
+        return Ok(Dropped::Modpack);
+    }
+    if has("pack.mcmeta") {
+        return Ok(match under("data/") {
+            true => Dropped::DataPack,
+            false => Dropped::Pack(packs::Kind::Resource),
+        });
+    }
+    if under("shaders/") {
+        return Ok(Dropped::Pack(packs::Kind::Shader));
+    }
+    if FILES.iter().any(|f| has(f))
+        || under("saves/")
+        || FOLDERS.iter().any(|f| under(&format!("{f}/")))
+    {
+        return Ok(Dropped::Instance);
+    }
+    Err(format!(
+        "{name} is neither a pack nor a shared instance: nothing in it that Horizon reads."
+    ))
+}
+
+/// Where an archive entry goes in the instance's folder, when it is one an instance holds and
+/// stays inside it.
+fn target(home: &Path, relative: &str) -> Option<PathBuf> {
+    let path = Path::new(relative);
+    if relative.ends_with('/') || !path.components().all(|c| matches!(c, Component::Normal(_))) {
+        return None;
+    }
+    let top = relative.split('/').next()?;
+    let kept = FILES.contains(&relative)
+        || (relative.contains('/') && (FOLDERS.contains(&top) || top == "saves"));
+    kept.then(|| home.join(path))
+}
+
+/// Makes a new instance from a shared one: `file` is a `.mrpack` without mod loaders or a game
+/// folder `.zip`. Named after the pack (or the file), with "(2)" when the name is taken.
+pub fn import_instance(file: &Path, progress: &dyn Fn(&str, f32)) -> Result<Instance, String> {
+    import_into(file, progress, &|name| instances::create(name, None))
+}
+
+/// [`import_instance`] with the instance made by `create`.
+pub fn import_into(
+    file: &Path,
+    progress: &dyn Fn(&str, f32),
+    create: &dyn Fn(&str) -> Result<Instance, String>,
+) -> Result<Instance, String> {
+    if what(file)? != Dropped::Instance {
+        return Err(format!("{} is not a shared instance.", name_of(file)));
+    }
+    let mut zip = open(file)?;
+    let mrpack = zip.index_for_name(INDEX).is_some();
+    let index = match mrpack {
+        true => Some(read_index(&mut zip)?),
+        false => None,
+    };
+    let stem = file
+        .file_stem()
+        .map(|s| s.to_string_lossy().into_owned())
+        .unwrap_or_else(|| "Imported".into());
+    let base = index
+        .as_ref()
+        .and_then(|i| i["name"].as_str())
+        .map(str::trim)
+        .filter(|n| !n.is_empty())
+        .map(str::to_string)
+        .unwrap_or(stem);
+    let instance = (1..20)
+        .map(|n| match n {
+            1 => base.clone(),
+            n => format!("{base} ({n})"),
+        })
+        .find_map(|name| create(&name).ok())
+        .ok_or_else(|| format!("Could not make an instance called {base}."))?;
+    let home = instance.home.clone();
+    let filled = fill(&mut zip, index.as_ref(), &home, progress);
+    if let Err(e) = filled {
+        let _ = fs::remove_dir_all(&home);
+        return Err(e);
+    }
+    Ok(instance)
+}
+
+fn fill(
+    zip: &mut zip::ZipArchive<fs::File>,
+    index: Option<&serde_json::Value>,
+    home: &Path,
+    progress: &dyn Fn(&str, f32),
+) -> Result<(), String> {
+    let count = zip.len();
+    for i in 0..count {
+        let mut entry = zip.by_index(i).map_err(|e| e.to_string())?;
+        let name = entry.name().to_string();
+        let relative = match index {
+            Some(_) => match OVERRIDES.iter().find_map(|o| name.strip_prefix(o)) {
+                Some(r) => r.to_string(),
+                None => continue,
+            },
+            None => name.clone(),
+        };
+        let Some(to) = target(home, &relative) else {
+            continue;
+        };
+        fs::create_dir_all(to.parent().expect("inside home")).map_err(|e| e.to_string())?;
+        let mut out = fs::File::create(&to).map_err(|e| format!("{}: {e}", to.display()))?;
+        std::io::copy(&mut entry, &mut out).map_err(|e| format!("{}: {e}", to.display()))?;
+        progress(
+            &format!("Copying {relative}"),
+            (i + 1) as f32 / count as f32,
+        );
+    }
+    let files = index
+        .and_then(|i| i["files"].as_array())
+        .cloned()
+        .unwrap_or_default();
+    for f in files {
+        if f["env"]["client"] == "unsupported" {
+            continue;
+        }
+        let relative = f["path"].as_str().unwrap_or_default();
+        let to = target(home, relative)
+            .ok_or_else(|| format!("{relative} isn't a place an instance keeps files."))?;
+        let file = FileRef {
+            url: f["downloads"][0].as_str().unwrap_or_default().to_string(),
+            name: to.file_name().unwrap().to_string_lossy().into_owned(),
+            size: f["fileSize"].as_u64().unwrap_or(0),
+            sha512: f["hashes"]["sha512"].as_str().map(str::to_ascii_lowercase),
+            sha256: None,
+            sha1: f["hashes"]["sha1"].as_str().map(str::to_ascii_lowercase),
+            primary: true,
+        };
+        let folder = to.parent().expect("inside home");
+        download::fetch(&file, folder, &|p| progress(&file.name, p))
+            .map_err(|e| format!("{relative}: {e}"))?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+#[path = "import/tests.rs"]
+mod tests;
diff --git a/launcher/src/import/tests.rs b/launcher/src/import/tests.rs
new file mode 100644
index 000000000..1287b475e
--- /dev/null
+++ b/launcher/src/import/tests.rs
@@ -0,0 +1,208 @@
+use super::*;
+use crate::export::{export, Format};
+use std::io::Write;
+use std::time::Duration;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-import-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+fn zip_file(path: &Path, files: &[(&str, &[u8])]) {
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    let mut zip = zip::ZipWriter::new(fs::File::create(path).unwrap());
+    for (name, bytes) in files {
+        zip.start_file(*name, zip::write::SimpleFileOptions::default())
+            .unwrap();
+        zip.write_all(bytes).unwrap();
+    }
+    zip.finish().unwrap();
+}
+
+fn put(path: &Path, bytes: &[u8]) {
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(path, bytes).unwrap();
+}
+
+/// Makes instances as folders of `root`, refusing a name already taken, as the launcher does.
+fn maker(root: &Path) -> impl Fn(&str) -> Result<Instance, String> + '_ {
+    move |name: &str| {
+        let home = root.join(crate::modpacks::slug(name));
+        if home.exists() {
+            return Err(format!("There is already an instance called {name}."));
+        }
+        fs::create_dir_all(&home).unwrap();
+        Ok(Instance {
+            id: crate::modpacks::slug(name),
+            name: name.into(),
+            kind: instances::Kind::Own,
+            work: home.clone(),
+            home,
+            icon: None,
+            group: None,
+            version: None,
+            played: Duration::ZERO,
+            last_played: None,
+            launch: Default::default(),
+        })
+    }
+}
+
+const NONE: &dyn Fn(&str, f32) = &|_, _| {};
+
+#[test]
+fn says_what_a_dropped_file_is() {
+    let dir = scratch("what");
+    let mrpack = |name: &str, deps: &str| {
+        let path = dir.join(name);
+        let index = format!(r#"{{"formatVersion":1,"name":"P","files":[],"dependencies":{deps}}}"#);
+        zip_file(&path, &[("modrinth.index.json", index.as_bytes())]);
+        path
+    };
+    let cases: Vec<(PathBuf, Result<Dropped, ()>)> = vec![
+        (
+            mrpack("shared.mrpack", r#"{"minecraft":"26.3"}"#),
+            Ok(Dropped::Instance),
+        ),
+        (
+            mrpack(
+                "java.mrpack",
+                r#"{"minecraft":"1.21.1","fabric-loader":"0.16"}"#,
+            ),
+            Ok(Dropped::Modpack),
+        ),
+        {
+            let p = dir.join("cf.zip");
+            zip_file(
+                &p,
+                &[("manifest.json", b"{}"), ("overrides/config/a.toml", b"")],
+            );
+            (p, Ok(Dropped::Modpack))
+        },
+        {
+            let p = dir.join("rp.zip");
+            zip_file(&p, &[("pack.mcmeta", b"{}"), ("assets/a.png", b"")]);
+            (p, Ok(Dropped::Pack(packs::Kind::Resource)))
+        },
+        {
+            let p = dir.join("dp.zip");
+            zip_file(
+                &p,
+                &[
+                    ("pack.mcmeta", b"{}"),
+                    ("data/a/function/f.mcfunction", b""),
+                ],
+            );
+            (p, Ok(Dropped::DataPack))
+        },
+        {
+            let p = dir.join("sp.zip");
+            zip_file(&p, &[("shaders/final.fsh", b"")]);
+            (p, Ok(Dropped::Pack(packs::Kind::Shader)))
+        },
+        {
+            let p = dir.join("glow.hshader");
+            put(&p, b"PK");
+            (p, Ok(Dropped::Pack(packs::Kind::Shader)))
+        },
+        {
+            let p = dir.join("folder.zip");
+            zip_file(
+                &p,
+                &[("options.txt", b"lang:fr_ch\n"), ("saves/W/level.dat", b"")],
+            );
+            (p, Ok(Dropped::Instance))
+        },
+        {
+            let p = dir.join("random.zip");
+            zip_file(&p, &[("readme.txt", b"")]);
+            (p, Err(()))
+        },
+        {
+            let p = dir.join("picture.png");
+            put(&p, b"png");
+            (p, Err(()))
+        },
+    ];
+    for (file, want) in cases {
+        assert_eq!(what(&file).map_err(|_| ()), want, "{}", file.display());
+    }
+    fs::remove_dir_all(&dir).unwrap();
+}
+
+#[test]
+fn an_export_comes_back_as_an_instance_and_nothing_escapes_its_folder() {
+    let dir = scratch("roundtrip");
+    let home = dir.join("from");
+    put(&home.join("options.txt"), b"lang:fr_ch\n");
+    put(&home.join("resourcepacks/Glass.zip"), b"glass");
+    put(
+        &home.join("horizon-mods/coords/horizon-mod.toml"),
+        b"id = \"coords\"\n",
+    );
+    put(&home.join("saves/Base/region/r.0.0.mca"), b"region");
+    put(&home.join("saves/Base/level.dat"), b"not nbt");
+    let made = dir.join("instances");
+    for format in [Format::Mrpack, Format::Zip] {
+        let out = dir.join(format!("Shared.{}", format.extension()));
+        export(&home, "Shared", format, &["Base".into()], &[], &out).unwrap();
+        let i = import_into(&out, NONE, &maker(&made)).unwrap();
+        for f in [
+            "options.txt",
+            "resourcepacks/Glass.zip",
+            "horizon-mods/coords/horizon-mod.toml",
+            "saves/Base/region/r.0.0.mca",
+        ] {
+            assert_eq!(
+                fs::read(i.home.join(f)).unwrap(),
+                fs::read(home.join(f)).unwrap(),
+                "{f}"
+            );
+        }
+    }
+    // The .mrpack took the pack's name; the zip came second and got "(2)".
+    assert!(made.join("shared").is_dir() && made.join("shared-2").is_dir());
+
+    // A zip that reaches out of its folder, or carries what an instance doesn't keep.
+    let evil = dir.join("evil.zip");
+    zip_file(
+        &evil,
+        &[
+            ("options.txt", b"ok"),
+            ("../outside.txt", b"no"),
+            ("saves/../../up.txt", b"no"),
+            ("logs/latest.log", b"no"),
+            ("session.json", b"no"),
+        ],
+    );
+    let i = import_into(&evil, NONE, &maker(&made)).unwrap();
+    assert!(i.home.join("options.txt").is_file());
+    assert!(!dir.join("outside.txt").exists() && !made.join("up.txt").exists());
+    assert!(!i.home.join("logs").exists() && !i.home.join("session.json").exists());
+
+    // A file to download from anywhere but Modrinth is refused, and the half-made folder goes.
+    let index = r#"{"formatVersion":1,"name":"Far","dependencies":{"minecraft":"26.3"},
+        "files":[{"path":"resourcepacks/x.zip","hashes":{"sha1":"00","sha512":"00"},
+        "downloads":["https://example.com/x.zip"],"fileSize":1}]}"#;
+    let far = dir.join("far.mrpack");
+    zip_file(&far, &[("modrinth.index.json", index.as_bytes())]);
+    let refused = import_into(&far, NONE, &maker(&made)).unwrap_err();
+    assert!(refused.contains("resourcepacks/x.zip"), "{refused}");
+    assert!(!made.join("far").exists());
+
+    let java = dir.join("java.mrpack");
+    zip_file(
+        &java,
+        &[(
+            "modrinth.index.json",
+            br#"{"name":"J","files":[],"dependencies":{"neoforge":"21"}}"#,
+        )],
+    );
+    assert!(import_into(&java, NONE, &maker(&made)).is_err());
+    fs::remove_dir_all(&dir).unwrap();
+}
diff --git a/launcher/src/import_page.rs b/launcher/src/import_page.rs
new file mode 100644
index 000000000..c6aa9bb97
--- /dev/null
+++ b/launcher/src/import_page.rs
@@ -0,0 +1,132 @@
+//! Files dropped anywhere on the window (`horizon_launcher::import`): a shared instance becomes
+//! a new instance, a Java modpack goes to the Modpacks import, a resource or shader pack into
+//! the selected instance. The Packs section and the world rows take their own drops first.
+use super::*;
+use gpui::ExternalPaths;
+use horizon_launcher::import::{self, Dropped};
+use std::path::PathBuf;
+
+#[derive(Default)]
+pub(super) struct Importing {
+    /// Shared instances being made.
+    busy: usize,
+    /// What the last drop did, or why not.
+    note: Option<Result<String, String>>,
+}
+
+impl Launcher {
+    pub(super) fn import_dropped(&mut self, files: Vec<PathBuf>, cx: &mut Context<Self>) {
+        for file in files {
+            let name = file
+                .file_name()
+                .map(|n| n.to_string_lossy().into_owned())
+                .unwrap_or_default();
+            match import::what(&file) {
+                Err(e) => self.importing.note = Some(Err(e)),
+                Ok(Dropped::Instance) => self.import_instance(file, cx),
+                Ok(Dropped::Modpack) => {
+                    self.show_modpack(None);
+                    self.pack_job(move |log| horizon_launcher::modpacks::import(&file, log));
+                    self.importing.note = Some(Ok(format!(
+                        "{name} is a Java modpack: importing it on the Modpacks page."
+                    )));
+                }
+                Ok(Dropped::Pack(_)) => {
+                    let Some(i) = self.selected_instance().cloned() else {
+                        continue;
+                    };
+                    self.importing.note =
+                        Some(horizon_launcher::packs::add(&i.home, &file).map(|p| {
+                            format!(
+                                "Added {} to {}'s packs: switch it on under Packs.",
+                                p.title, i.name
+                            )
+                        }));
+                    self.game_packs.stale();
+                }
+                Ok(Dropped::DataPack) => {
+                    self.importing.note = Some(Err(format!(
+                        "{name} is a data pack: drop it on a world on Home, or install it into \
+                         one from there."
+                    )))
+                }
+            }
+        }
+    }
+
+    fn import_instance(&mut self, file: PathBuf, cx: &mut Context<Self>) {
+        self.importing.busy += 1;
+        self.importing.note = None;
+        let task = cx
+            .background_executor()
+            .spawn(async move { import::import_instance(&file, &|_, _| {}) });
+        cx.spawn(async move |this, cx| {
+            let made = task.await;
+            let _ = this.update(cx, |this, cx| {
+                this.importing.busy -= 1;
+                this.importing.note = Some(made.map(|i| {
+                    this.reload_instances();
+                    this.select_instance(&i);
+                    this.go(Page::Play);
+                    format!("Made the instance {} from the shared file.", i.name)
+                }));
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    /// The root's drop target: every drop the sections don't take.
+    pub(super) fn import_drop_target(
+        &self,
+        root: Stateful<Div>,
+        cx: &mut Context<Self>,
+    ) -> Stateful<Div> {
+        root.on_drop(cx.listener(|this, paths: &ExternalPaths, _, cx| {
+            this.import_dropped(paths.paths().to_vec(), cx);
+            cx.notify();
+        }))
+    }
+
+    /// What the last drop did, in a corner over the page until closed.
+    pub(super) fn import_note(&self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let line = match (&self.importing.note, self.importing.busy) {
+            (_, n) if n > 0 => text(theme::LABEL)
+                .text_color(t.ink_soft)
+                .child("Making the instance from the shared file…"),
+            (Some(Ok(said)), _) => text(theme::LABEL)
+                .text_color(t.ink_soft)
+                .child(said.clone()),
+            (Some(Err(e)), _) => text(theme::LABEL).text_color(t.danger).child(e.clone()),
+            (None, _) => return None,
+        };
+        Some(
+            div()
+                .absolute()
+                .bottom(px(24.))
+                .right(px(24.))
+                .w(px(440.))
+                .child(
+                    plate(&t)
+                        .w_full()
+                        .flex()
+                        .items_center()
+                        .gap(px(12.))
+                        .px(px(16.))
+                        .py(px(12.))
+                        .border_1()
+                        .border_color(t.rule)
+                        .bg(t.page)
+                        .child(blocks::icon("download", 18., t.accent))
+                        .child(div().flex_1().min_w_0().child(line))
+                        .child(button("import-close", "Close", Kind::Ghost, &t).on_click(
+                            cx.listener(|this, _: &ClickEvent, _, cx| {
+                                this.importing.note = None;
+                                cx.notify();
+                            }),
+                        )),
+                ),
+        )
+    }
+}
diff --git a/launcher/src/instances.rs b/launcher/src/instances.rs
new file mode 100644
index 000000000..0d47386cb
--- /dev/null
+++ b/launcher/src/instances.rs
@@ -0,0 +1,496 @@
+//! Instances: separate game folders, each with its own worlds, options and packs.
+//!
+//! Nothing that exists moves. The game's home (`backend::game_home`) stays the default instance,
+//! "Horizon", with its saves and options where they are. Imported modpacks (`ports/<pack>/home/`)
+//! and registry modpacks (`horizon-packs/<id>/home/`) are instances too, played from their own
+//! folders as before. New instances get `instances/<slug>/` in the game's home. What the player
+//! chooses about an instance (its name, icon, group) is kept in `instances.json` in the
+//! launcher's data folder, so renaming one never moves a folder.
+use crate::backend;
+use crate::browser::horizon::pack as registry_pack;
+use crate::launch::Launch;
+use crate::modpacks;
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+/// The default instance's id: the game's home itself.
+pub const DEFAULT: &str = "horizon";
+const FILE: &str = "instances.json";
+/// Where new instances live, in the game's home.
+const OWN: &str = "instances";
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Kind {
+    /// The game's home: what every player had before instances.
+    Default,
+    /// Made in the launcher: `instances/<slug>/`.
+    Own,
+    /// An imported Java modpack (modpacks.rs).
+    Port,
+    /// A modpack from Horizon's registry.
+    Pack,
+}
+
+/// What an instance shows in the sidebar: a block or item texture from the player's prepared
+/// files (never shipped), or a colour.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Icon {
+    /// A texture name: `grass_block` (block/ is looked in first, then item/).
+    Texture(String),
+    /// `#rrggbb`.
+    Colour(String),
+}
+
+impl Icon {
+    /// `#3fa7d6` is a colour; a texture's name is lowercase letters, digits and `_`.
+    pub fn parse(text: &str) -> Result<Icon, String> {
+        let text = text.trim();
+        if let Some(hex) = text.strip_prefix('#') {
+            if hex.len() == 6 && hex.chars().all(|c| c.is_ascii_hexdigit()) {
+                return Ok(Icon::Colour(format!("#{}", hex.to_ascii_lowercase())));
+            }
+        } else if !text.is_empty()
+            && text
+                .chars()
+                .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_')
+        {
+            return Ok(Icon::Texture(text.into()));
+        }
+        Err(format!(
+            "{text}: give a block or item name (grass_block) or a colour (#3fa7d6)"
+        ))
+    }
+
+    /// The texture's file in prepared resources, if it is a texture they hold.
+    pub fn texture(&self, resources: &Path) -> Option<PathBuf> {
+        let Icon::Texture(name) = self else {
+            return None;
+        };
+        let textures = resources.join("assets/minecraft/textures");
+        ["block", "item"]
+            .iter()
+            .map(|kind| textures.join(kind).join(format!("{name}.png")))
+            .find(|p| p.is_file())
+    }
+}
+
+/// The player's choices about one instance.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Meta {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub icon: Option<Icon>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub group: Option<String>,
+    /// The Horizon version this instance plays, kept when newer ones are installed. None: the
+    /// launcher's own version, which follows updates.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    /// Seconds played in it, every run started by the launcher (the window or `play`) added up.
+    #[serde(default, skip_serializing_if = "is_zero")]
+    pub played_secs: u64,
+    /// When its last run ended, in seconds since 1970.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub last_played: Option<u64>,
+    /// What runs around the game: a pre-launch command, a wrapper, variables (`launch`).
+    #[serde(default, skip_serializing_if = "Launch::is_empty")]
+    pub launch: Launch,
+}
+
+fn is_zero(n: &u64) -> bool {
+    *n == 0
+}
+
+/// `instances.json`: each instance's choices, by id.
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+struct Store {
+    #[serde(default)]
+    instances: BTreeMap<String, Meta>,
+}
+
+impl Store {
+    fn load(data: &Path) -> Store {
+        fs::read_to_string(data.join(FILE))
+            .ok()
+            .and_then(|t| serde_json::from_str(&t).ok())
+            .unwrap_or_default()
+    }
+    fn save(&self, data: &Path) -> Result<(), String> {
+        fs::create_dir_all(data).map_err(|e| format!("{}: {e}", data.display()))?;
+        let text = serde_json::to_string_pretty(self).unwrap();
+        fs::write(data.join(FILE), text).map_err(|e| format!("{FILE}: {e}"))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Instance {
+    /// `horizon`, an own instance's folder name, `port:<pack>` or `pack:<id>`.
+    pub id: String,
+    pub name: String,
+    pub kind: Kind,
+    /// The folder the pack's tools work in: the game's home for Default and Own instances.
+    pub work: PathBuf,
+    /// The game folder it plays in: saves, options.txt, packs.
+    pub home: PathBuf,
+    pub icon: Option<Icon>,
+    pub group: Option<String>,
+    /// Its pinned Horizon version, if any (`Meta::version`).
+    pub version: Option<String>,
+    pub played: Duration,
+    pub last_played: Option<SystemTime>,
+    /// What runs around the game (`launch::wrap`).
+    pub launch: Launch,
+}
+
+impl Instance {
+    /// The installed version this instance plays: its pinned one, else `requested` (the
+    /// command line's `--version`) or the launcher's (`backend::resolve_version`).
+    pub fn resolve_version(&self, requested: Option<&str>) -> Result<String, String> {
+        match (requested, &self.version) {
+            (None, Some(pinned)) => backend::resolve_version(Some(pinned)).map_err(|_| {
+                format!(
+                    "{} plays {pinned}, which is not installed: install it, or horizon-launcher \
+                     instance version \"{}\" latest",
+                    self.name, self.name
+                )
+            }),
+            _ => backend::resolve_version(requested),
+        }
+    }
+}
+
+/// The instances, by the default game home and the launcher's data folder: Horizon first, then
+/// by group and name.
+pub fn list() -> Vec<Instance> {
+    list_in(&backend::game_home(), &backend::data_dir())
+}
+
+fn list_in(game_home: &Path, data: &Path) -> Vec<Instance> {
+    let store = Store::load(data);
+    let mut found = vec![(
+        DEFAULT.to_string(),
+        "Horizon".to_string(),
+        Kind::Default,
+        game_home.to_path_buf(),
+        game_home.to_path_buf(),
+    )];
+    let mut own: Vec<_> = fs::read_dir(game_home.join(OWN))
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter(|e| e.path().is_dir())
+        .filter_map(|e| e.file_name().into_string().ok())
+        .collect();
+    own.sort();
+    for slug in own {
+        let dir = game_home.join(OWN).join(&slug);
+        found.push((slug.clone(), slug, Kind::Own, dir.clone(), dir));
+    }
+    for p in modpacks::list_in(&game_home.join("ports")) {
+        let home = modpacks::profile_home(&p.work);
+        found.push((
+            format!("port:{}", p.slug),
+            p.title().into(),
+            Kind::Port,
+            p.work,
+            home,
+        ));
+    }
+    for p in registry_pack::list_in(&game_home.join("horizon-packs")) {
+        let home = registry_pack::home(&p.work);
+        found.push((format!("pack:{}", p.id), p.name, Kind::Pack, p.work, home));
+    }
+    let mut out: Vec<Instance> = found
+        .into_iter()
+        .map(|(id, name, kind, work, home)| {
+            let meta = store.instances.get(&id).cloned().unwrap_or_default();
+            Instance {
+                name: meta.name.unwrap_or(name),
+                icon: meta.icon,
+                group: meta.group,
+                version: meta.version,
+                played: Duration::from_secs(meta.played_secs),
+                last_played: meta
+                    .last_played
+                    .map(|s| UNIX_EPOCH + Duration::from_secs(s)),
+                launch: meta.launch,
+                id,
+                kind,
+                work,
+                home,
+            }
+        })
+        .collect();
+    out[1..].sort_by_key(|i| (i.group.clone(), i.name.to_lowercase()));
+    out
+}
+
+/// The instance an id, a name (any case) or a pack's folder name names.
+pub fn find(query: &str) -> Result<Instance, String> {
+    find_in(&list(), query)
+}
+
+fn find_in(all: &[Instance], query: &str) -> Result<Instance, String> {
+    let q = query.trim();
+    let bare = |id: &str| id.split_once(':').map_or(id, |(_, rest)| rest).to_string();
+    all.iter()
+        .find(|i| i.id == q)
+        .or_else(|| all.iter().find(|i| i.name.eq_ignore_ascii_case(q)))
+        .or_else(|| all.iter().find(|i| bare(&i.id) == q))
+        .cloned()
+        .ok_or_else(|| format!("No instance {q}: horizon-launcher instance list shows them"))
+}
+
+/// The instance Play starts: the one picked in the launcher, else Horizon.
+pub fn selected() -> Instance {
+    let all = list();
+    backend::Settings::load()
+        .instance
+        .and_then(|id| all.iter().find(|i| i.id == id).cloned())
+        .unwrap_or_else(|| all[0].clone())
+}
+
+pub fn select(query: &str) -> Result<Instance, String> {
+    let instance = find(query)?;
+    let mut settings = backend::Settings::load();
+    settings.instance = (instance.kind != Kind::Default).then(|| instance.id.clone());
+    settings.save();
+    Ok(instance)
+}
+
+/// What a copy of a game folder leaves out: other instances and packs, logs and crash reports,
+/// caches, data collection's state, and sign-in sessions (a session never leaves its folder).
+const NOT_COPIED: &[&str] = &[
+    OWN,
+    "ports",
+    "horizon-packs",
+    "logs",
+    "crash-reports",
+    "sessions",
+    "telemetry",
+    "mod-browser",
+    ".horizon-cache",
+];
+
+/// Files of the player, not of one instance, that a new instance starts with: the keys and video
+/// settings, and the offline name (so the player stays the same player in its worlds).
+const PLAYER_FILES: &[&str] = &["options.txt", "horizon-player.txt"];
+
+/// Creates an instance named `name`: empty but for the player's options and offline name, or a
+/// copy of `from`'s game folder (its worlds, options and packs). Nothing of `from` changes.
+pub fn create(name: &str, from: Option<&str>) -> Result<Instance, String> {
+    let from = from.map(find).transpose()?;
+    create_in(
+        &backend::game_home(),
+        &backend::data_dir(),
+        name,
+        from.as_ref(),
+    )
+}
+
+fn create_in(
+    game_home: &Path,
+    data: &Path,
+    name: &str,
+    from: Option<&Instance>,
+) -> Result<Instance, String> {
+    let name = name.trim();
+    if name.is_empty() {
+        return Err("An instance needs a name.".into());
+    }
+    let all = list_in(game_home, data);
+    if all.iter().any(|i| i.name.eq_ignore_ascii_case(name)) {
+        return Err(format!("There is already an instance called {name}."));
+    }
+    if let Some(from) = from.filter(|f| matches!(f.kind, Kind::Port | Kind::Pack)) {
+        return Err(format!(
+            "{} plays its pack's mods: import the pack again for a second copy.",
+            from.name
+        ));
+    }
+    let base = modpacks::slug(name);
+    let taken = |s: &str| s == DEFAULT || game_home.join(OWN).join(s).exists();
+    let slug = (1..)
+        .map(|n| {
+            if n == 1 {
+                base.clone()
+            } else {
+                format!("{base}-{n}")
+            }
+        })
+        .find(|s| !taken(s))
+        .unwrap();
+    let dir = game_home.join(OWN).join(&slug);
+    let made = match from {
+        Some(from) => copy_home(&from.home, &dir),
+        None => fs::create_dir_all(&dir).and_then(|()| {
+            for f in PLAYER_FILES {
+                let own = game_home.join(f);
+                if own.is_file() {
+                    fs::copy(own, dir.join(f))?;
+                }
+            }
+            Ok(())
+        }),
+    };
+    if let Err(e) = made {
+        let _ = fs::remove_dir_all(&dir);
+        return Err(format!("Could not make {}: {e}", dir.display()));
+    }
+    let mut store = Store::load(data);
+    let meta = store.instances.entry(slug.clone()).or_default();
+    meta.name = (name != slug).then(|| name.to_string());
+    meta.icon = from.and_then(|f| f.icon.clone());
+    meta.group = from.and_then(|f| f.group.clone());
+    store.save(data)?;
+    find_in(&list_in(game_home, data), &slug)
+}
+
+fn copy_home(from: &Path, to: &Path) -> std::io::Result<()> {
+    fs::create_dir_all(to)?;
+    for entry in fs::read_dir(from)? {
+        let entry = entry?;
+        let name = entry.file_name();
+        if NOT_COPIED.iter().any(|n| name == *n) {
+            continue;
+        }
+        let path = entry.path();
+        if entry.file_type()?.is_dir() {
+            copy_dir(&path, &to.join(&name))?;
+        } else {
+            fs::copy(&path, to.join(&name))?;
+        }
+    }
+    Ok(())
+}
+
+fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
+    fs::create_dir_all(to)?;
+    for entry in fs::read_dir(from)? {
+        let entry = entry?;
+        let target = to.join(entry.file_name());
+        if entry.file_type()?.is_dir() {
+            copy_dir(&entry.path(), &target)?;
+        } else {
+            fs::copy(entry.path(), target)?;
+        }
+    }
+    Ok(())
+}
+
+/// Changes what the player chose about an instance: its name, icon or group. No folder moves.
+pub fn edit(query: &str, change: impl FnOnce(&mut Meta)) -> Result<Instance, String> {
+    edit_in(&backend::game_home(), &backend::data_dir(), query, change)
+}
+
+fn edit_in(
+    game_home: &Path,
+    data: &Path,
+    query: &str,
+    change: impl FnOnce(&mut Meta),
+) -> Result<Instance, String> {
+    let all = list_in(game_home, data);
+    let instance = find_in(&all, query)?;
+    let mut store = Store::load(data);
+    let meta = store.instances.entry(instance.id.clone()).or_default();
+    change(meta);
+    meta.name = meta.name.take().map(|n| n.trim().to_string());
+    meta.group = meta
+        .group
+        .take()
+        .map(|g| g.trim().to_string())
+        .filter(|g| !g.is_empty());
+    if let Some(name) = &meta.name {
+        if name.is_empty() {
+            return Err("An instance needs a name.".into());
+        }
+        // Only a new name is checked: an import can share a name, and changing anything
+        // else about it must still work.
+        let renamed = !name.eq_ignore_ascii_case(&instance.name);
+        if renamed
+            && all
+                .iter()
+                .any(|i| i.id != instance.id && i.name.eq_ignore_ascii_case(name))
+        {
+            return Err(format!("There is already an instance called {name}."));
+        }
+    }
+    store.save(data)?;
+    find_in(&list_in(game_home, data), &instance.id)
+}
+
+/// Adds a finished run of the game to the instance's play time (by id: a renamed instance keeps
+/// it).
+pub fn record_play(id: &str, played: Duration) -> Result<(), String> {
+    record_play_in(&backend::data_dir(), id, played, SystemTime::now())
+}
+
+fn record_play_in(
+    data: &Path,
+    id: &str,
+    played: Duration,
+    ended: SystemTime,
+) -> Result<(), String> {
+    let mut store = Store::load(data);
+    let meta = store.instances.entry(id.to_string()).or_default();
+    meta.played_secs = meta.played_secs.saturating_add(played.as_secs());
+    meta.last_played = ended.duration_since(UNIX_EPOCH).ok().map(|d| d.as_secs());
+    store.save(data)
+}
+
+/// "12 min", "3 h 05 min", "140 h": the play time as players read it.
+pub fn play_time(played: Duration) -> String {
+    let minutes = played.as_secs() / 60;
+    match (minutes / 60, minutes % 60) {
+        (0, 0) => crate::i18n::tr("under a minute").into(),
+        (0, m) => format!("{m} min"),
+        (h, m) if h < 100 => format!("{h} h {m:02} min"),
+        (h, _) => format!("{h} h"),
+    }
+}
+
+/// Turns the game's command into this instance: its own game folder, and a pack's mods. The
+/// player's answers that hold everywhere follow it in: data collection and No AI as the
+/// launcher has them, and options.txt and the offline name when it has none yet.
+pub fn apply(cmd: &mut Command, instance: &Instance) -> Result<(), String> {
+    match instance.kind {
+        Kind::Default => return Ok(()),
+        Kind::Own => {
+            fs::create_dir_all(&instance.home)
+                .map_err(|e| format!("{}: {e}", instance.home.display()))?;
+            cmd.current_dir(&instance.home)
+                .env("HORIZON_HOME", &instance.home);
+        }
+        Kind::Port | Kind::Pack => modpacks::apply_profile(cmd, &instance.work)?,
+    }
+    follow_player(&backend::game_home(), &instance.home);
+    Ok(())
+}
+
+fn follow_player(game_home: &Path, home: &Path) {
+    for f in PLAYER_FILES {
+        if !home.join(f).exists() && game_home.join(f).is_file() {
+            let _ = fs::copy(game_home.join(f), home.join(f));
+        }
+    }
+    let consent = horizon_telemetry::consent::Consent::path(game_home);
+    if consent.is_file() {
+        let to = horizon_telemetry::consent::Consent::path(home);
+        let _ = fs::create_dir_all(to.parent().unwrap());
+        let _ = fs::copy(consent, to);
+    }
+    let no_ai = horizon_core::no_ai::is_on(game_home);
+    if horizon_core::no_ai::is_on(home) != no_ai {
+        let _ = horizon_core::no_ai::set(home, no_ai);
+    }
+}
+
+#[cfg(test)]
+#[path = "instances/tests.rs"]
+mod tests;
diff --git a/launcher/src/instances/tests.rs b/launcher/src/instances/tests.rs
new file mode 100644
index 000000000..b2e2fe6fe
--- /dev/null
+++ b/launcher/src/instances/tests.rs
@@ -0,0 +1,272 @@
+use super::*;
+use std::collections::BTreeMap;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-instances-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+fn put(path: &Path, text: &str) {
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(path, text).unwrap();
+}
+
+/// Every file under `dir`, relative, with its bytes.
+fn files(dir: &Path) -> BTreeMap<PathBuf, Vec<u8>> {
+    fn walk(root: &Path, dir: &Path, out: &mut BTreeMap<PathBuf, Vec<u8>>) {
+        for e in fs::read_dir(dir).unwrap().flatten() {
+            let p = e.path();
+            if p.is_dir() {
+                walk(root, &p, out);
+            } else {
+                out.insert(p.strip_prefix(root).unwrap().into(), fs::read(&p).unwrap());
+            }
+        }
+    }
+    let mut out = BTreeMap::new();
+    walk(dir, dir, &mut out);
+    out
+}
+
+/// A game home as a player has it before instances: worlds, options, packs, a session, an
+/// imported modpack and a registry modpack with their own worlds.
+fn player_home(home: &Path) {
+    put(&home.join("saves/World/level.dat"), "world");
+    put(&home.join("saves/World/region/r.0.0.mca"), "region");
+    put(&home.join("saves/Other/level.dat"), "other");
+    put(&home.join("options.txt"), "fov:90\n");
+    put(&home.join("horizon-player.txt"), "name:Player123\n");
+    put(&home.join("resourcepacks/faithful.zip"), "pack");
+    put(&home.join("logs/latest.log"), "log");
+    put(&home.join("sessions/a.json"), "token");
+    put(&home.join("telemetry/consent.json"), "{}");
+    let pack = horizon_port_pack::import::Pack {
+        name: "Small Pack".into(),
+        ..Default::default()
+    };
+    put(
+        &home.join("ports/small-pack/pack.json"),
+        &serde_json::to_string(&pack).unwrap(),
+    );
+    put(
+        &home.join("ports/small-pack/home/saves/Modded/level.dat"),
+        "modded",
+    );
+    put(
+        &home.join("horizon-packs/cozy/pack.json"),
+        r#"{"id":"cozy","name":"Cozy","version":"1.0.0","sha256":"00","mods":[]}"#,
+    );
+    put(
+        &home.join("horizon-packs/cozy/home/saves/Cozy/level.dat"),
+        "cozy",
+    );
+}
+
+#[test]
+fn existing_worlds_stay_where_they_are_and_every_folder_becomes_an_instance() {
+    let root = scratch("migrate");
+    let (home, data) = (root.join("horizon"), root.join("launcher"));
+    player_home(&home);
+    let before = files(&home);
+
+    // A launcher with instances, on a player's existing folders: no instances.json yet.
+    let all = list_in(&home, &data);
+    let ids: Vec<&str> = all.iter().map(|i| i.id.as_str()).collect();
+    assert_eq!(ids, [DEFAULT, "pack:cozy", "port:small-pack"]);
+    assert_eq!(all[0].name, "Horizon");
+    assert_eq!(all[0].home, home);
+    assert_eq!(all[1].home, home.join("horizon-packs/cozy/home"));
+    assert_eq!(all[2].name, "Small Pack");
+    assert_eq!(all[2].home, home.join("ports/small-pack/home"));
+
+    // Everything the player can do with instances, then not one byte of theirs has moved.
+    let empty = create_in(&home, &data, "Survival", None).unwrap();
+    let copy = create_in(&home, &data, "My copy", Some(&all[0])).unwrap();
+    edit_in(&home, &data, DEFAULT, |m| m.name = Some("Main".into())).unwrap();
+    edit_in(&home, &data, "Small Pack", |m| {
+        m.icon = Some(Icon::Texture("diamond".into()));
+        m.group = Some("Modded".into());
+    })
+    .unwrap();
+    let after = files(&home);
+    for (path, bytes) in &before {
+        assert_eq!(after.get(path), Some(bytes), "{} changed", path.display());
+    }
+    assert!(!data.join("settings.json").exists());
+
+    // The empty one has only the player's options and name; the copy has the worlds and
+    // packs, never the sessions, logs, data collection or other instances.
+    assert_eq!(empty.home, home.join("instances/survival"));
+    let empty_files: Vec<PathBuf> = files(&empty.home).into_keys().collect();
+    assert_eq!(
+        empty_files,
+        [PathBuf::from("horizon-player.txt"), "options.txt".into()]
+    );
+    let copied = files(&copy.home);
+    for kept in [
+        "saves/World/region/r.0.0.mca",
+        "saves/Other/level.dat",
+        "resourcepacks/faithful.zip",
+    ] {
+        assert_eq!(copied[Path::new(kept)], before[Path::new(kept)]);
+    }
+    assert!(copied.keys().all(|p| {
+        let top = p.components().next().unwrap().as_os_str().to_str().unwrap();
+        !NOT_COPIED.contains(&top)
+    }));
+
+    let all = list_in(&home, &data);
+    assert_eq!(all[0].name, "Main");
+    let port = find_in(&all, "port:small-pack").unwrap();
+    assert_eq!(port.group.as_deref(), Some("Modded"));
+    assert_eq!(port.home, home.join("ports/small-pack/home"));
+    fs::remove_dir_all(&root).unwrap();
+}
+
+#[test]
+fn names_stay_unique_and_packs_are_not_copied() {
+    let root = scratch("names");
+    let (home, data) = (root.join("horizon"), root.join("launcher"));
+    player_home(&home);
+    create_in(&home, &data, "Survival", None).unwrap();
+    assert!(create_in(&home, &data, "survival", None).is_err());
+    assert!(create_in(&home, &data, "  ", None).is_err());
+    // Another name with the same folder name gets the next free folder.
+    let second = create_in(&home, &data, "Survival!", None).unwrap();
+    assert_eq!(second.id, "survival-2");
+    assert_eq!(second.name, "Survival!");
+    assert!(edit_in(&home, &data, "survival-2", |m| m.name =
+        Some("SURVIVAL".into()))
+    .is_err());
+    let port = find_in(&list_in(&home, &data), "small-pack").unwrap();
+    assert!(create_in(&home, &data, "Pack copy", Some(&port)).is_err());
+    assert!(!home.join("instances/pack-copy").exists());
+    // An empty group is no group.
+    let grouped = edit_in(&home, &data, "Survival", |m| m.group = Some(" ".into())).unwrap();
+    assert_eq!(grouped.group, None);
+    // An import named like an instance: both can still change everything but their names.
+    let mut store = Store::load(&data);
+    store.instances.entry(port.id.clone()).or_default().name = Some("Survival".into());
+    store.save(&data).unwrap();
+    let launched = edit_in(&home, &data, "survival", |m| {
+        m.launch.wrapper = "nice".into()
+    })
+    .unwrap();
+    assert_eq!(launched.launch.wrapper, "nice");
+    assert!(edit_in(&home, &data, "survival-2", |m| m.name =
+        Some("survival".into()))
+    .is_err());
+    fs::remove_dir_all(&root).unwrap();
+}
+
+#[test]
+fn an_instance_follows_the_players_answers() {
+    let root = scratch("follow");
+    let (main, own) = (root.join("main"), root.join("own"));
+    put(&main.join("options.txt"), "fov:90\n");
+    put(&main.join("horizon-player.txt"), "name:Player123\n");
+    put(&main.join("telemetry/consent.json"), r#"{"version":1}"#);
+    horizon_core::no_ai::set(&main, true).unwrap();
+    put(&own.join("options.txt"), "fov:70\n");
+    follow_player(&main, &own);
+    assert_eq!(
+        fs::read_to_string(own.join("options.txt")).unwrap(),
+        "fov:70\n"
+    );
+    assert_eq!(
+        fs::read_to_string(own.join("horizon-player.txt")).unwrap(),
+        "name:Player123\n"
+    );
+    assert_eq!(
+        fs::read_to_string(own.join("telemetry/consent.json")).unwrap(),
+        r#"{"version":1}"#
+    );
+    assert!(horizon_core::no_ai::is_on(&own));
+    horizon_core::no_ai::set(&main, false).unwrap();
+    follow_player(&main, &own);
+    assert!(!horizon_core::no_ai::is_on(&own));
+    fs::remove_dir_all(&root).unwrap();
+}
+
+#[test]
+fn icons_are_a_texture_name_or_a_colour() {
+    assert_eq!(Icon::parse("#3FA7D6"), Ok(Icon::Colour("#3fa7d6".into())));
+    assert_eq!(
+        Icon::parse("grass_block"),
+        Ok(Icon::Texture("grass_block".into()))
+    );
+    for bad in ["#12345", "../x", "Grass", "", "#zzzzzz"] {
+        assert!(Icon::parse(bad).is_err(), "{bad}");
+    }
+    let root = scratch("icon");
+    put(
+        &root.join("assets/minecraft/textures/item/diamond.png"),
+        "png",
+    );
+    let diamond = Icon::Texture("diamond".into()).texture(&root).unwrap();
+    assert!(diamond.ends_with("item/diamond.png"));
+    assert_eq!(Icon::Texture("stone".into()).texture(&root), None);
+    fs::remove_dir_all(&root).unwrap();
+}
+
+#[test]
+fn an_instance_keeps_its_own_version_until_it_follows_updates_again() {
+    let root = scratch("version");
+    let (home, data) = (root.join("horizon"), root.join("launcher"));
+    player_home(&home);
+    create_in(&home, &data, "Old world", None).unwrap();
+    let pinned = edit_in(&home, &data, "Old world", |m| {
+        m.version = Some("v0.1.0".into())
+    })
+    .unwrap();
+    assert_eq!(pinned.version.as_deref(), Some("v0.1.0"));
+    // Renaming keeps it; the other instances follow the launcher's version.
+    let renamed = edit_in(&home, &data, "old-world", |m| m.name = Some("Older".into())).unwrap();
+    assert_eq!(renamed.version.as_deref(), Some("v0.1.0"));
+    assert!(list_in(&home, &data)
+        .iter()
+        .filter(|i| i.id != "old-world")
+        .all(|i| i.version.is_none()));
+    let follows = edit_in(&home, &data, "Older", |m| m.version = None).unwrap();
+    assert_eq!(follows.version, None);
+    fs::remove_dir_all(&root).unwrap();
+}
+
+#[test]
+fn play_time_adds_up_per_instance_and_survives_a_rename() {
+    let root = scratch("play-time");
+    let (home, data) = (root.join("home"), root.join("data"));
+    fs::create_dir_all(home.join(OWN).join("skyblock")).unwrap();
+    let ended = UNIX_EPOCH + Duration::from_secs(1_800_000_000);
+    record_play_in(&data, "skyblock", Duration::from_secs(25 * 60 + 10), ended).unwrap();
+    edit_in(&home, &data, "skyblock", |m| m.name = Some("Sky".into())).unwrap();
+    let later = ended + Duration::from_secs(3600);
+    record_play_in(&data, "skyblock", Duration::from_secs(40 * 60), later).unwrap();
+    let all = list_in(&home, &data);
+    let sky = find_in(&all, "Sky").unwrap();
+    assert_eq!(sky.played, Duration::from_secs(65 * 60 + 10));
+    assert_eq!(sky.last_played, Some(later));
+    let default = find_in(&all, DEFAULT).unwrap();
+    assert_eq!(
+        (default.played, default.last_played),
+        (Duration::ZERO, None)
+    );
+    // Never played: nothing written for it.
+    let text = fs::read_to_string(data.join(FILE)).unwrap();
+    assert!(!text.contains("horizon"), "{text}");
+    fs::remove_dir_all(&root).unwrap();
+}
+
+#[test]
+fn play_time_reads_as_minutes_then_hours() {
+    let t = |s| play_time(Duration::from_secs(s));
+    assert_eq!(t(59), "under a minute");
+    assert_eq!(t(12 * 60 + 59), "12 min");
+    assert_eq!(t(3 * 3600 + 5 * 60), "3 h 05 min");
+    assert_eq!(t(140 * 3600 + 7 * 60), "140 h");
+}
diff --git a/launcher/src/instances_page.rs b/launcher/src/instances_page.rs
new file mode 100644
index 000000000..e94fffaaa
--- /dev/null
+++ b/launcher/src/instances_page.rs
@@ -0,0 +1,672 @@
+//! Instances in the window (`horizon_launcher::instances`): the sidebar's list, by group, and the
+//! dialog that makes one (empty, or a copy of the selected one) or changes its name, group and
+//! icon.
+use super::*;
+use gpui::RenderImage;
+use horizon_launcher::instances::{self, Icon, Instance, Kind as InstanceKind};
+use servers_page::Field;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+/// Textures offered as icons, when the player's prepared files hold them: block faces and items
+/// that read well at sidebar size.
+const TEXTURES: [&str; 24] = [
+    "grass_block_side",
+    "oak_planks",
+    "oak_log",
+    "cobblestone",
+    "bricks",
+    "bookshelf",
+    "crafting_table_front",
+    "tnt_side",
+    "sand",
+    "snow",
+    "ice",
+    "obsidian",
+    "netherrack",
+    "end_stone",
+    "glowstone",
+    "diamond_ore",
+    "diamond",
+    "emerald",
+    "apple",
+    "ender_pearl",
+    "iron_pickaxe",
+    "diamond_sword",
+    "bow",
+    "book",
+];
+
+/// Colours offered as icons: Horizon's accent and a few that sit beside it in both themes.
+const COLOURS: [&str; 8] = [
+    "#5b3fd6", "#3f7fd6", "#2f9e8f", "#4f9e2f", "#c9a227", "#d9732f", "#c4405a", "#7d7591",
+];
+
+/// The dialog: a new instance (`editing` None) or one being changed. Its name and group are the
+/// text fields `Field::InstanceName` and `Field::InstanceGroup`.
+pub(super) struct InstanceDialog {
+    editing: Option<String>,
+    /// A new instance copies the selected one's worlds, options and packs.
+    copy: bool,
+    icon: Option<Icon>,
+    error: Option<String>,
+    busy: bool,
+}
+
+/// The instances and their icons as images, kept between frames.
+#[derive(Default)]
+pub(super) struct Instances {
+    pub(super) list: Vec<Instance>,
+    pub(super) dialog: Option<InstanceDialog>,
+    icons: HashMap<(String, u32), Option<Arc<RenderImage>>>,
+}
+
+impl Launcher {
+    pub(super) fn reload_instances(&mut self) {
+        self.instances.list = instances::list();
+    }
+
+    /// The instance Play starts.
+    pub(super) fn selected_instance(&self) -> Option<&Instance> {
+        let id = self
+            .settings
+            .instance
+            .as_deref()
+            .unwrap_or(instances::DEFAULT);
+        let list = &self.instances.list;
+        list.iter().find(|i| i.id == id).or(list.first())
+    }
+
+    /// The installed version `instance` plays: its own, else the launcher's.
+    pub(super) fn version_of(&self, instance: &Instance) -> Option<&String> {
+        match &instance.version {
+            Some(own) => self.installed.iter().find(|t| *t == own),
+            None => self.launcher_version(),
+        }
+    }
+
+    /// Keeps the selected instance on `tag`, or lets it follow the launcher's version.
+    pub(super) fn pin_version(&mut self, tag: Option<String>) {
+        let Some(id) = self.selected_instance().map(|i| i.id.clone()) else {
+            return;
+        };
+        match instances::edit(&id, |m| m.version = tag) {
+            Ok(_) => self.reload_instances(),
+            Err(e) => self.client_error = Some(e),
+        }
+    }
+
+    pub(super) fn select_instance(&mut self, instance: &Instance) {
+        self.settings.instance =
+            (instance.kind != InstanceKind::Default).then(|| instance.id.clone());
+        self.settings.save();
+    }
+
+    /// A texture from the selected version's prepared files, its first frame, drawn as pixels.
+    fn texture_image(&mut self, name: &str, size: f32) -> Option<Arc<RenderImage>> {
+        let tag = self.selected().filter(|t| backend::is_prepared(t))?.clone();
+        let scale = self.scale;
+        self.instances
+            .icons
+            .entry((name.to_string(), (size * scale) as u32))
+            .or_insert_with(|| {
+                let path = Icon::Texture(name.into()).texture(&backend::resources(&tag))?;
+                let png = image::open(path).ok()?.to_rgba8();
+                let w = png.width() as usize;
+                // An animated texture is its frames one under another: the first is square.
+                let texels: Vec<[u8; 4]> = png.pixels().take(w * w).map(|p| p.0).collect();
+                Some(art::bake(&texels, w, w, size / w as f32, scale))
+            })
+            .clone()
+    }
+
+    /// An instance's icon, `size` points square.
+    pub(super) fn instance_icon(&mut self, instance: &Instance, size: f32) -> AnyElement {
+        let t = self.theme;
+        let framed = |d: Div| {
+            d.flex()
+                .flex_none()
+                .items_center()
+                .justify_center()
+                .size(px(size))
+                .border_2()
+                .border_color(t.outline)
+        };
+        match &instance.icon {
+            Some(Icon::Colour(hex)) => {
+                let rgb = u32::from_str_radix(&hex[1..], 16).unwrap_or(0);
+                return framed(div().bg(gpui::rgb(rgb)))
+                    .child(
+                        blocks::pixel((size * 0.42).round(), FontWeight::BOLD)
+                            .text_color(gpui::white())
+                            .child(initial(&instance.name)),
+                    )
+                    .into_any_element();
+            }
+            Some(Icon::Texture(name)) => {
+                if let Some(image) = self.texture_image(name, size - 8.) {
+                    return framed(div().bg(t.well))
+                        .child(gpui::img(image).size(px(size - 8.)))
+                        .into_any_element();
+                }
+            }
+            None if instance.kind == InstanceKind::Default => {
+                if let Some(grass) = self.vanilla_icon() {
+                    return div()
+                        .flex()
+                        .items_center()
+                        .justify_center()
+                        .size(px(size))
+                        .child(gpui::img(grass).size(px(size - 4.)))
+                        .into_any_element();
+                }
+            }
+            None => {}
+        }
+        blocks::slot(None, &instance.name, size, &t).into_any_element()
+    }
+
+    /// The sidebar's instances: those without a group, then each group under its name.
+    pub(super) fn instance_items(
+        &mut self,
+        heading: impl Fn(String) -> Div,
+        cx: &mut Context<Self>,
+    ) -> Vec<AnyElement> {
+        let t = self.theme;
+        let selected = self.selected_instance().map(|i| i.id.clone());
+        let on_packs = self.page == Page::Mods && self.mods.on_modpacks();
+        let mut out = Vec::new();
+        let mut group = None;
+        for i in self.instances.list.clone() {
+            if i.group != group {
+                group = i.group.clone();
+                if let Some(g) = &group {
+                    out.push(heading(g.to_uppercase()).into_any_element());
+                }
+            }
+            let tag = self.version_of(&i).cloned();
+            let prepared = tag.as_deref().is_some_and(backend::is_prepared);
+            let (open, sub) = match i.kind {
+                InstanceKind::Default | InstanceKind::Own => (
+                    self.page == Page::Play && selected.as_ref() == Some(&i.id),
+                    match (&tag, &i.version) {
+                        (None, Some(own)) => trf("{version} is not installed", &[("version", own)]),
+                        (None, None) => tr("No version installed").into(),
+                        (Some(_), _) if !prepared => tr("Needs preparing").into(),
+                        (Some(tag), Some(_)) => format!("{} · {tag}", tr("Ready")),
+                        (Some(_), None) => tr("Ready").into(),
+                    },
+                ),
+                InstanceKind::Port => {
+                    let slug = &i.id["port:".len()..];
+                    let summary = self.packs.iter().find(|p| p.slug == slug);
+                    (
+                        on_packs && self.pack_open.as_deref() == Some(slug),
+                        summary.map_or_else(|| tr("Modpack").into(), |p| p.summary()),
+                    )
+                }
+                InstanceKind::Pack => (false, tr("From Horizon's registry").into()),
+            };
+            let dot = matches!(i.kind, InstanceKind::Default | InstanceKind::Own).then(|| {
+                div()
+                    .absolute()
+                    .left(px(42.))
+                    .top(px(42.))
+                    .size(px(10.))
+                    .bg(if prepared { t.success } else { t.warn })
+                    .border_2()
+                    .border_color(t.side)
+            });
+            let icon = self.instance_icon(&i, 44.);
+            let clicked = i.clone();
+            out.push(
+                blocks::side_item(format!("side-instance-{}", i.id).into(), open, &t)
+                    .child(icon)
+                    .children(dot)
+                    .child(
+                        div()
+                            .flex()
+                            .flex_col()
+                            .min_w_0()
+                            .child(
+                                blocks::pixel(15., FontWeight::MEDIUM)
+                                    .text_color(t.ink)
+                                    .truncate()
+                                    .child(i.name.clone()),
+                            )
+                            .child(
+                                text(theme::CAPTION)
+                                    .text_color(t.muted)
+                                    .truncate()
+                                    .child(sub),
+                            ),
+                    )
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        match clicked.kind {
+                            InstanceKind::Default | InstanceKind::Own => {
+                                this.select_instance(&clicked);
+                                this.go(Page::Play);
+                            }
+                            InstanceKind::Port => {
+                                this.show_modpack(Some(clicked.id["port:".len()..].into()))
+                            }
+                            InstanceKind::Pack => this.show_modpack(None),
+                        }
+                        cx.notify();
+                    }))
+                    .into_any_element(),
+            );
+        }
+        out
+    }
+
+    /// Opens the dialog for a new instance, or for changing `editing`.
+    pub(super) fn open_instance_dialog(&mut self, editing: Option<Instance>) {
+        let (name, group) = editing
+            .as_ref()
+            .map(|i| (i.name.clone(), i.group.clone().unwrap_or_default()))
+            .unwrap_or_default();
+        *self.servers.text(Field::InstanceName) = name;
+        *self.servers.text(Field::InstanceGroup) = group;
+        self.servers.focus_soon = Some(Field::InstanceName);
+        self.instances.dialog = Some(InstanceDialog {
+            icon: editing.as_ref().and_then(|i| i.icon.clone()),
+            editing: editing.map(|i| i.id),
+            copy: false,
+            error: None,
+            busy: false,
+        });
+    }
+
+    /// Escape closes the dialog. Whether it did.
+    pub(super) fn instance_escape(&mut self) -> bool {
+        if self.instances.dialog.as_ref().is_some_and(|d| !d.busy) {
+            self.instances.dialog = None;
+            return true;
+        }
+        false
+    }
+
+    /// Creates or changes the instance as the dialog says. A copy can be gigabytes of worlds, so
+    /// the work runs in the background.
+    pub(super) fn save_instance(&mut self, cx: &mut Context<Self>) {
+        let selected = self.selected_instance().map(|i| i.id.clone());
+        let name = self.servers.value(Field::InstanceName).trim().to_string();
+        let group = Some(self.servers.value(Field::InstanceGroup).to_string());
+        let Some(d) = self.instances.dialog.as_mut().filter(|d| !d.busy) else {
+            return;
+        };
+        let icon = d.icon.clone();
+        let editing = d.editing.clone();
+        let copy = selected.filter(|_| d.copy);
+        d.busy = true;
+        d.error = None;
+        let task = cx.background_executor().spawn(async move {
+            let id = match editing {
+                Some(id) => id,
+                None => instances::create(&name, copy.as_deref())?.id,
+            };
+            instances::edit(&id, |m| {
+                m.name = Some(name);
+                m.group = group;
+                m.icon = icon;
+            })
+        });
+        cx.spawn(async move |this, cx| {
+            let result = task.await;
+            let _ = this.update(cx, |this, cx| {
+                match result {
+                    Ok(instance) => {
+                        this.instances.dialog = None;
+                        this.select_instance(&instance);
+                        this.reload_instances();
+                        if matches!(instance.kind, InstanceKind::Default | InstanceKind::Own) {
+                            this.go(Page::Play);
+                        }
+                    }
+                    Err(e) => {
+                        if let Some(d) = &mut this.instances.dialog {
+                            d.busy = false;
+                            d.error = Some(e);
+                        }
+                    }
+                }
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    pub(super) fn instance_dialog(&mut self, cx: &mut Context<Self>) -> Option<Stateful<Div>> {
+        let t = self.theme;
+        let d = self.instances.dialog.as_ref()?;
+        let (editing, copy, icon, error, busy) = (
+            d.editing.is_some(),
+            d.copy,
+            d.icon.clone(),
+            d.error.clone(),
+            d.busy,
+        );
+        let from = self
+            .selected_instance()
+            .map_or_else(|| "Horizon".into(), |i| i.name.clone());
+        let row = |label: &'static str, control: AnyElement| {
+            div()
+                .flex()
+                .flex_col()
+                .gap(px(8.))
+                .child(caps(label).text_color(t.muted))
+                .child(control)
+        };
+        let mut body = div()
+            .flex()
+            .flex_col()
+            .gap(px(20.))
+            .p(px(24.))
+            .child(
+                blocks::pixel(22., FontWeight::MEDIUM)
+                    .text_color(t.ink)
+                    .child(if editing {
+                        "Edit instance"
+                    } else {
+                        "New instance"
+                    }),
+            )
+            .child(row(
+                "Name",
+                self.field(Field::InstanceName, "My instance", 400., cx)
+                    .into_any_element(),
+            ));
+        if !editing {
+            let weak = cx.entity().downgrade();
+            body = body.child(row(
+                "Start from",
+                segments(
+                    "instance-from",
+                    &[(false, "Empty"), (true, "A copy of the selected one")],
+                    copy,
+                    &t,
+                    move |copy, _, cx| {
+                        let _ = weak.update(cx, |this, cx| {
+                            if let Some(d) = &mut this.instances.dialog {
+                                d.copy = copy;
+                            }
+                            cx.notify();
+                        });
+                    },
+                )
+                .into_any_element(),
+            ));
+            body = body.child(text(theme::CAPTION).text_color(t.muted).child(if copy {
+                format!("{from}'s worlds, options and packs are copied; {from} stays as it is.")
+            } else {
+                "Its own worlds and packs; your options and player name come along.".to_string()
+            }));
+        }
+        body = body.child(row(
+            "Group",
+            self.field(Field::InstanceGroup, "No group", 400., cx)
+                .into_any_element(),
+        ));
+        let mut tiles = div().flex().flex_wrap().gap(px(6.));
+        let tile = |id: String, chosen: bool| {
+            div()
+                .id(SharedString::from(id))
+                .flex()
+                .items_center()
+                .justify_center()
+                .size(px(40.))
+                .border_2()
+                .border_color(if chosen { t.accent } else { t.rule })
+                .cursor_pointer()
+                .hover(move |s| s.border_color(t.outline))
+        };
+        let none = icon.is_none();
+        tiles = tiles.child(
+            tile("instance-icon-none".into(), none)
+                .child(text(theme::MICRO).text_color(t.muted).child("NONE"))
+                .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                    if let Some(d) = &mut this.instances.dialog {
+                        d.icon = None;
+                    }
+                    cx.notify();
+                })),
+        );
+        for name in TEXTURES {
+            let Some(image) = self.texture_image(name, 28.) else {
+                continue;
+            };
+            let chosen = icon == Some(Icon::Texture(name.into()));
+            tiles = tiles.child(
+                tile(format!("instance-icon-{name}"), chosen)
+                    .bg(t.well)
+                    .child(gpui::img(image).size(px(28.)))
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        if let Some(d) = &mut this.instances.dialog {
+                            d.icon = Some(Icon::Texture(name.into()));
+                        }
+                        cx.notify();
+                    })),
+            );
+        }
+        for hex in COLOURS {
+            let chosen = icon == Some(Icon::Colour(hex.into()));
+            let rgb = u32::from_str_radix(&hex[1..], 16).unwrap_or(0);
+            tiles = tiles.child(
+                tile(format!("instance-icon-{hex}"), chosen)
+                    .child(div().size(px(28.)).bg(gpui::rgb(rgb)))
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        if let Some(d) = &mut this.instances.dialog {
+                            d.icon = Some(Icon::Colour(hex.into()));
+                        }
+                        cx.notify();
+                    })),
+            );
+        }
+        body = body.child(row("Icon", tiles.into_any_element()));
+        if self.selected().is_none_or(|t| !backend::is_prepared(t)) {
+            body = body.child(
+                text(theme::CAPTION)
+                    .text_color(t.muted)
+                    .child("Block and item icons come from your prepared game files: prepare a version to see them."),
+            );
+        }
+        if let Some(e) = error {
+            body = body.child(text(theme::CAPTION).text_color(t.danger).child(e));
+        }
+        let cancel = button("instance-cancel", "Cancel", Kind::Secondary, &t);
+        let label = match (editing, busy, copy) {
+            (_, true, true) => "Copying…",
+            (true, false, _) => "Save",
+            _ => "Create",
+        };
+        let save = button("instance-save", label, Kind::Primary, &t);
+        // A modpack becomes an instance by being imported, on the Mods page.
+        let import = (!editing && !busy).then(|| {
+            button("instance-import", "Import a modpack…", Kind::Ghost, &t)
+                .mr_auto()
+                .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                    this.instances.dialog = None;
+                    this.show_modpack(None);
+                    cx.notify();
+                }))
+        });
+        let foot = div()
+            .flex()
+            .justify_end()
+            .gap(px(8.))
+            .px(px(24.))
+            .py(px(16.))
+            .border_t_1()
+            .border_color(t.rule)
+            .children(import);
+        let foot = if busy {
+            foot.child(disabled(cancel)).child(disabled(save))
+        } else {
+            foot.child(cancel.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                this.instances.dialog = None;
+                cx.notify();
+            })))
+            .child(save.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                this.save_instance(cx);
+                cx.notify();
+            })))
+        };
+        let card = plate(&t)
+            .flex()
+            .flex_col()
+            .w_full()
+            .max_w(px(560.))
+            .bg(t.page)
+            .border_1()
+            .border_color(t.rule)
+            .child(body)
+            .child(foot);
+        Some(
+            div()
+                .id("instance-dialog")
+                .absolute()
+                .top_0()
+                .left_0()
+                .size_full()
+                .flex()
+                .flex_col()
+                .items_center()
+                .px(px(32.))
+                .py(px(24.))
+                .bg(t.page.opacity(0.92))
+                .on_scroll_wheel(|_, _, cx| cx.stop_propagation())
+                .occlude()
+                .child(card),
+        )
+    }
+
+    /// The Play page's row for the selected instance: its folder, and changing, copying or
+    /// exporting it.
+    pub(super) fn instance_row(&mut self, n: usize, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let instance = self.selected_instance()?.clone();
+        let (home, edit, name) = (
+            instance.home.clone(),
+            instance.clone(),
+            instance.name.clone(),
+        );
+        // Under the name, wrapping: six actions don't fit beside it at the window's narrowest.
+        let actions = div()
+            .flex()
+            .flex_wrap()
+            .gap(px(8.))
+            .mt(px(6.))
+            .ml(px(-14.))
+            .child(
+                button("instance-edit", "Edit…", Kind::Ghost, &t).on_click(cx.listener(
+                    move |this, _: &ClickEvent, _, cx| {
+                        this.open_instance_dialog(Some(edit.clone()));
+                        cx.notify();
+                    },
+                )),
+            )
+            .child(
+                button("instance-copy", "Copy…", Kind::Ghost, &t).on_click(cx.listener(
+                    move |this, _: &ClickEvent, _, cx| {
+                        this.open_instance_dialog(None);
+                        *this.servers.text(Field::InstanceName) = format!("{name} copy");
+                        if let Some(d) = &mut this.instances.dialog {
+                            d.copy = true;
+                        }
+                        cx.notify();
+                    },
+                )),
+            )
+            .child(
+                button(
+                    "instance-export",
+                    if self.export.is_some() {
+                        "Close export"
+                    } else {
+                        "Export…"
+                    },
+                    Kind::Ghost,
+                    &t,
+                )
+                .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                    this.toggle_export();
+                    cx.notify();
+                })),
+            )
+            .child(
+                button(
+                    "instance-launch",
+                    if self.launch.is_some() {
+                        "Close launch"
+                    } else {
+                        "Launch…"
+                    },
+                    Kind::Ghost,
+                    &t,
+                )
+                .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                    this.toggle_launch();
+                    cx.notify();
+                })),
+            )
+            .child(self.shortcut_button(&instance, cx))
+            .child(
+                button("instance-folder", "Open folder", Kind::Ghost, &t).on_click(
+                    move |_, _, cx| {
+                        let _ = std::fs::create_dir_all(&home);
+                        cx.open_with_system(&home);
+                    },
+                ),
+            );
+        Some(index_row(
+            n,
+            tr("Instance"),
+            Some(
+                div()
+                    .flex()
+                    .flex_col()
+                    .child(
+                        div()
+                            .flex()
+                            .items_baseline()
+                            .gap(px(10.))
+                            .child(instance.name.clone())
+                            .child(
+                                text(theme::CAPTION)
+                                    .text_color(t.muted)
+                                    .child(played_line(&instance)),
+                            ),
+                    )
+                    .children(self.shortcut_note(&instance.id))
+                    .child(actions)
+                    .into_any_element(),
+            ),
+            None,
+            &t,
+        ))
+    }
+}
+
+/// "3 h 05 min in total · last played today", or "Not played yet".
+fn played_line(instance: &Instance) -> String {
+    match instance.last_played {
+        Some(when) => trf(
+            "{time} in total · last played {when}",
+            &[
+                ("time", &instances::play_time(instance.played)),
+                ("when", &worlds_page::ago(when)),
+            ],
+        ),
+        None => tr("Not played yet").into(),
+    }
+}
+
+/// The first letter or digit of a name, for an icon without a picture.
+fn initial(name: &str) -> String {
+    name.chars()
+        .find(|c| c.is_alphanumeric())
+        .unwrap_or('?')
+        .to_uppercase()
+        .to_string()
+}
diff --git a/launcher/src/internet.rs b/launcher/src/internet.rs
index 76ab8dab8..d4f70ed18 100644
--- a/launcher/src/internet.rs
+++ b/launcher/src/internet.rs
@@ -267,7 +267,7 @@ impl Launcher {
         )
         .bg(self.theme.plate)
         .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
-            cx.write_to_clipboard(gpui::ClipboardItem::new_string(text.clone()));
+            copy_to_clipboard(cx, gpui::ClipboardItem::new_string(text.clone()));
             this.internet.copied = Some((text.clone(), Instant::now()));
             cx.notify();
         }))
diff --git a/launcher/src/language_page.rs b/launcher/src/language_page.rs
new file mode 100644
index 000000000..5dd940311
--- /dev/null
+++ b/launcher/src/language_page.rs
@@ -0,0 +1,35 @@
+//! Settings' Language row (`horizon_launcher::i18n`): the system's language, or one the player
+//! picks, each named in itself.
+use super::*;
+use horizon_launcher::i18n::Language;
+
+impl Launcher {
+    pub(super) fn language_row(&self, cx: &mut Context<Self>) -> Div {
+        let t = self.theme;
+        let mut options = vec![(None, "System")];
+        options.extend(Language::ALL.map(|l| (Some(l), l.name())));
+        let picker = segments("language", &options, self.settings.language, &t, {
+            let this = cx.entity().downgrade();
+            move |choice, _, cx| {
+                let _ = this.update(cx, |this, cx| {
+                    this.settings.language = choice;
+                    this.settings.save();
+                    i18n::set(this.settings.language());
+                    cx.notify();
+                });
+            }
+        });
+        let said = trf(
+            "System follows your computer's language: {language} here. A string not translated \
+             yet shows in English.",
+            &[("language", Language::system().name())],
+        );
+        index_row(
+            0,
+            tr("Language"),
+            Some(div().child(said).into_any_element()),
+            Some(picker.into_any_element()),
+            &t,
+        )
+    }
+}
diff --git a/launcher/src/launch.rs b/launcher/src/launch.rs
new file mode 100644
index 000000000..0219c88ba
--- /dev/null
+++ b/launcher/src/launch.rs
@@ -0,0 +1,346 @@
+//! What runs around the game for one instance (`instances::Meta::launch`): a command run before
+//! it, a wrapper it runs through, and environment variables. All empty by default.
+//!
+//! [`wrap`] turns the game's command into one process that does all three, so the launcher still
+//! follows one program (its output, its exit, Stop):
+//!
+//! - Unix: `/bin/sh -c '(<pre-launch>) || exit; exec "$@"' horizon <wrapper…> <game> <args…>`.
+//!   The pre-launch command is the player's own shell line, run in the instance's folder; the
+//!   game's words go through `"$@"`, so they are never parsed by the shell. `exec` makes the
+//!   shell become the wrapper (or the game).
+//! - Windows: `cmd /D /S /C "<pre-launch> && <wrapper…> <game> <args…>"`, each word quoted.
+//!
+//! Without a pre-launch command the wrapper is the program itself, and no shell runs.
+use crate::backend::split_args;
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::ffi::{OsStr, OsString};
+use std::process::Command;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Launch {
+    /// A shell command run in the instance's folder before the game; the game starts only if it
+    /// succeeds.
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub pre_launch: String,
+    /// A command line the game runs through, such as `nice -n 5` (quotes group a word).
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub wrapper: String,
+    /// Environment variables for the game (and the two commands above).
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub env: BTreeMap<String, String>,
+    /// Linux: run the game through Feral's GameMode (`gamemoderun`), when it is installed.
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub gamemode: bool,
+    /// Linux: MangoHud's overlay (`mangohud`), when it is installed.
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub mangohud: bool,
+    /// Linux: the dedicated graphics card of a computer with two (PRIME render offload).
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub dedicated_gpu: bool,
+}
+
+fn is_false(b: &bool) -> bool {
+    !*b
+}
+
+/// What this Linux computer has for the three switches. Elsewhere, nothing.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct Found {
+    pub gamemode: bool,
+    pub mangohud: bool,
+    /// More than one graphics card.
+    pub two_gpus: bool,
+    /// NVIDIA's own driver is loaded: offload asks for it, not Mesa.
+    pub nvidia: bool,
+}
+
+/// `HORIZON_LAUNCHER_LINUX_TOOLS=gamemode,mangohud,gpu,nvidia`: what [`Found::here`] says is
+/// installed, on any system (for tests and screenshots).
+pub const TOOLS_ENV: &str = "HORIZON_LAUNCHER_LINUX_TOOLS";
+
+fn on_path(program: &str) -> bool {
+    std::env::var_os("PATH").is_some_and(|path| {
+        std::env::split_paths(&path).any(|dir| {
+            let file = dir.join(program);
+            #[cfg(unix)]
+            {
+                use std::os::unix::fs::PermissionsExt;
+                file.metadata()
+                    .is_ok_and(|m| m.is_file() && m.permissions().mode() & 0o111 != 0)
+            }
+            #[cfg(not(unix))]
+            file.is_file()
+        })
+    })
+}
+
+impl Found {
+    /// What is installed here: on Linux, `gamemoderun` and `mangohud` on the PATH, the cards
+    /// under `/sys/class/drm`, and `/proc/driver/nvidia`.
+    pub fn here() -> Found {
+        if let Some(list) = std::env::var_os(TOOLS_ENV) {
+            let list = list.to_string_lossy();
+            let has = |n: &str| list.split(',').any(|w| w.trim() == n);
+            return Found {
+                gamemode: has("gamemode"),
+                mangohud: has("mangohud"),
+                two_gpus: has("gpu"),
+                nvidia: has("nvidia"),
+            };
+        }
+        if !cfg!(target_os = "linux") {
+            return Found::default();
+        }
+        let cards = std::fs::read_dir("/sys/class/drm")
+            .into_iter()
+            .flatten()
+            .flatten()
+            .filter(|e| {
+                let name = e.file_name();
+                let name = name.to_string_lossy();
+                name.strip_prefix("card")
+                    .is_some_and(|n| !n.is_empty() && n.chars().all(|c| c.is_ascii_digit()))
+            })
+            .count();
+        Found {
+            gamemode: on_path("gamemoderun"),
+            mangohud: on_path("mangohud"),
+            two_gpus: cards >= 2,
+            nvidia: std::path::Path::new("/proc/driver/nvidia/gpus").is_dir(),
+        }
+    }
+
+    /// Whether any switch can be shown.
+    pub fn any(&self) -> bool {
+        self.gamemode || self.mangohud || self.two_gpus
+    }
+}
+
+/// The programs the switches put before the game (and the player's wrapper), outermost first.
+fn switch_programs(launch: &Launch, found: &Found) -> Vec<OsString> {
+    let mut out = Vec::new();
+    if launch.gamemode && found.gamemode {
+        out.push("gamemoderun".into());
+    }
+    if launch.mangohud && found.mangohud {
+        out.push("mangohud".into());
+    }
+    out
+}
+
+/// The variables the dedicated GPU switch sets: NVIDIA's offload variables with its driver,
+/// else Mesa's `DRI_PRIME`. The player's own variables come after and win.
+pub fn switch_env(launch: &Launch, found: &Found) -> Vec<(&'static str, &'static str)> {
+    match (launch.dedicated_gpu && found.two_gpus, found.nvidia) {
+        (false, _) => vec![],
+        (true, true) => vec![
+            ("__NV_PRIME_RENDER_OFFLOAD", "1"),
+            ("__VK_LAYER_NV_optimus", "NVIDIA_only"),
+            ("__GLX_VENDOR_LIBRARY_NAME", "nvidia"),
+        ],
+        (true, false) => vec![("DRI_PRIME", "1")],
+    }
+}
+
+impl Launch {
+    pub fn is_empty(&self) -> bool {
+        self == &Launch::default()
+    }
+
+    /// What it does, in one line, or None when nothing.
+    pub fn summary(&self) -> Option<String> {
+        let mut parts = Vec::new();
+        if !self.pre_launch.trim().is_empty() {
+            parts.push(format!("runs {} first", self.pre_launch.trim()));
+        }
+        if !self.wrapper.trim().is_empty() {
+            parts.push(format!("through {}", self.wrapper.trim()));
+        }
+        if self.gamemode {
+            parts.push("with GameMode".into());
+        }
+        if self.mangohud {
+            parts.push("with MangoHud".into());
+        }
+        if self.dedicated_gpu {
+            parts.push("on the dedicated GPU".into());
+        }
+        match self.env.len() {
+            0 => {}
+            1 => parts.push("with 1 variable".into()),
+            n => parts.push(format!("with {n} variables")),
+        }
+        (!parts.is_empty()).then(|| parts.join(", "))
+    }
+}
+
+fn valid_key(key: &str) -> bool {
+    let mut chars = key.chars();
+    chars
+        .next()
+        .is_some_and(|c| c.is_ascii_alphabetic() || c == '_')
+        && chars.all(|c| c.is_ascii_alphanumeric() || c == '_')
+}
+
+/// `KEY=value KEY2="two words"` (one line, or one per line) as variables.
+pub fn parse_env(text: &str) -> Result<BTreeMap<String, String>, String> {
+    let mut env = BTreeMap::new();
+    for word in split_args(text) {
+        let (key, value) = word
+            .split_once('=')
+            .ok_or_else(|| format!("{word}: write it as NAME=value"))?;
+        if !valid_key(key) {
+            return Err(format!(
+                "{key}: a variable's name is letters, digits and _, not starting with a digit"
+            ));
+        }
+        env.insert(key.to_string(), value.to_string());
+    }
+    Ok(env)
+}
+
+/// The variables as [`parse_env`] reads them back.
+pub fn env_line(env: &BTreeMap<String, String>) -> String {
+    env.iter()
+        .map(
+            |(k, v)| match v.is_empty() || v.contains([' ', '"', '\'', '\\']) {
+                true => format!("{k}=\"{}\"", v.replace('\\', "\\\\").replace('"', "\\\"")),
+                false => format!("{k}={v}"),
+            },
+        )
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+/// The Unix script: the pre-launch command (in a subshell, so its `exit` doesn't end the script
+/// before the message), then the rest of the arguments as the program.
+fn script(pre_launch: &str) -> String {
+    format!(
+        "(\n{pre_launch}\n) || {{ s=$?; echo \"The pre-launch command failed (exit $s), so the \
+         game did not start.\" >&2; exit $s; }}\nexec \"$@\""
+    )
+}
+
+/// A word quoted for a Windows command line, as programs built with the C runtime read it back.
+fn windows_quote(word: &OsStr) -> String {
+    let word = word.to_string_lossy();
+    if !word.is_empty() && !word.contains([' ', '\t', '"']) {
+        return word.into_owned();
+    }
+    let mut out = String::from("\"");
+    let mut slashes = 0;
+    for c in word.chars() {
+        match c {
+            '\\' => slashes += 1,
+            '"' => {
+                out.extend(std::iter::repeat_n('\\', slashes * 2 + 1));
+                out.push('"');
+                slashes = 0;
+            }
+            c => {
+                out.extend(std::iter::repeat_n('\\', slashes));
+                out.push(c);
+                slashes = 0;
+            }
+        }
+    }
+    out.extend(std::iter::repeat_n('\\', slashes * 2));
+    out.push('"');
+    out
+}
+
+/// How [`wrap`] runs a command on each system, apart from the variables and the folder: the
+/// program and its arguments.
+#[derive(Debug, PartialEq, Eq)]
+pub enum Plan {
+    /// Run as given (`words[0]` is the program).
+    Direct(Vec<OsString>),
+    /// `/bin/sh -c <script> horizon <words…>`.
+    Shell {
+        script: String,
+        words: Vec<OsString>,
+    },
+    /// `cmd /D /S /C "<line>"`: the line as cmd reads it.
+    Cmd { line: String },
+}
+
+/// The plan for `words` (the game's program and arguments) with `launch`, on Windows or not,
+/// with what the computer has for the switches.
+pub fn plan(launch: &Launch, words: Vec<OsString>, windows: bool, found: &Found) -> Plan {
+    let mut all = switch_programs(launch, found);
+    all.extend(split_args(&launch.wrapper).into_iter().map(OsString::from));
+    all.extend(words);
+    let pre = launch.pre_launch.trim();
+    match (pre.is_empty(), windows) {
+        (true, _) => Plan::Direct(all),
+        (false, false) => Plan::Shell {
+            script: script(pre),
+            words: all,
+        },
+        (false, true) => Plan::Cmd {
+            line: format!(
+                "{pre} && {}",
+                all.iter()
+                    .map(|w| windows_quote(w))
+                    .collect::<Vec<_>>()
+                    .join(" ")
+            ),
+        },
+    }
+}
+
+/// The game's command run with `launch`: a new command with the same folder and variables,
+/// plus the instance's variables. Call it last, after every argument is added.
+pub fn wrap(cmd: Command, launch: &Launch) -> Command {
+    if launch.is_empty() {
+        return cmd;
+    }
+    let words: Vec<OsString> = std::iter::once(cmd.get_program().to_owned())
+        .chain(cmd.get_args().map(OsStr::to_owned))
+        .collect();
+    // The override only shows the switches: they act on Linux.
+    let found = match cfg!(target_os = "linux") {
+        true => Found::here(),
+        false => Found::default(),
+    };
+    let mut out = match plan(launch, words, cfg!(windows), &found) {
+        Plan::Direct(words) => {
+            let mut c = Command::new(&words[0]);
+            c.args(&words[1..]);
+            c
+        }
+        Plan::Shell { script, words } => {
+            let mut c = Command::new("/bin/sh");
+            c.arg("-c").arg(script).arg("horizon").args(words);
+            c
+        }
+        Plan::Cmd { line } => {
+            let mut c = Command::new("cmd.exe");
+            #[cfg(windows)]
+            {
+                use std::os::windows::process::CommandExt;
+                c.raw_arg(format!("/D /S /C \"{line}\""));
+            }
+            #[cfg(not(windows))]
+            c.args(["/D", "/S", "/C", &line]);
+            c
+        }
+    };
+    if let Some(dir) = cmd.get_current_dir() {
+        out.current_dir(dir);
+    }
+    for (key, value) in cmd.get_envs() {
+        match value {
+            Some(value) => out.env(key, value),
+            None => out.env_remove(key),
+        };
+    }
+    out.envs(switch_env(launch, &found));
+    out.envs(&launch.env);
+    out
+}
+
+#[cfg(test)]
+#[path = "launch/tests.rs"]
+mod tests;
diff --git a/launcher/src/launch/tests.rs b/launcher/src/launch/tests.rs
new file mode 100644
index 000000000..3940488b6
--- /dev/null
+++ b/launcher/src/launch/tests.rs
@@ -0,0 +1,195 @@
+use super::*;
+
+fn os(words: &[&str]) -> Vec<OsString> {
+    words.iter().map(OsString::from).collect()
+}
+
+#[test]
+fn variables_are_read_and_written_back() {
+    let env = parse_env("MANGOHUD=1  DRI_PRIME=1\nNAME=\"two words\" EMPTY=").unwrap();
+    assert_eq!(env["MANGOHUD"], "1");
+    assert_eq!(env["NAME"], "two words");
+    assert_eq!(env["EMPTY"], "");
+    assert_eq!(parse_env(&env_line(&env)).unwrap(), env);
+    assert_eq!(
+        env_line(&env),
+        "DRI_PRIME=1 EMPTY=\"\" MANGOHUD=1 NAME=\"two words\""
+    );
+    assert!(parse_env("JUSTANAME").unwrap_err().contains("NAME=value"));
+    assert!(parse_env("1X=2")
+        .unwrap_err()
+        .contains("letters, digits and _"));
+    assert!(parse_env("").unwrap().is_empty());
+}
+
+#[test]
+fn a_summary_says_what_runs() {
+    assert_eq!(Launch::default().summary(), None);
+    let launch = Launch {
+        pre_launch: "./sync.sh".into(),
+        wrapper: "nice -n 5".into(),
+        env: parse_env("A=1 B=2").unwrap(),
+        ..Launch::default()
+    };
+    assert_eq!(
+        launch.summary().unwrap(),
+        "runs ./sync.sh first, through nice -n 5, with 2 variables"
+    );
+}
+
+#[test]
+fn each_system_gets_its_plan() {
+    let game = os(&["/opt/horizon-client", "--world", "My World"]);
+    let wrapper = Launch {
+        wrapper: "nice -n 5".into(),
+        ..Launch::default()
+    };
+    assert_eq!(
+        plan(&wrapper, game.clone(), false, &Found::default()),
+        Plan::Direct(os(&[
+            "nice",
+            "-n",
+            "5",
+            "/opt/horizon-client",
+            "--world",
+            "My World"
+        ]))
+    );
+    let both = Launch {
+        pre_launch: "echo hi".into(),
+        ..wrapper.clone()
+    };
+    let Plan::Shell { script, words } = plan(&both, game.clone(), false, &Found::default()) else {
+        panic!()
+    };
+    assert!(script.starts_with("(\necho hi\n) || "));
+    assert!(script.ends_with("\nexec \"$@\""));
+    assert_eq!(words[0], "nice");
+    assert_eq!(
+        plan(
+            &both,
+            os(&[r"C:\Horizon\horizon-client.exe", "--world", "My World"]),
+            true,
+            &Found::default()
+        ),
+        Plan::Cmd {
+            line: r#"echo hi && nice -n 5 C:\Horizon\horizon-client.exe --world "My World""#.into()
+        }
+    );
+}
+
+#[test]
+fn windows_words_are_quoted_as_the_c_runtime_reads_them() {
+    let q = |w: &str| windows_quote(OsStr::new(w));
+    assert_eq!(q("plain"), "plain");
+    assert_eq!(q("two words"), "\"two words\"");
+    assert_eq!(q(""), "\"\"");
+    assert_eq!(q(r#"say "hi""#), r#""say \"hi\"""#);
+    assert_eq!(q(r"C:\My Folder\"), r#""C:\My Folder\\""#);
+}
+
+#[test]
+fn nothing_to_add_leaves_the_command_as_it_is() {
+    let mut cmd = Command::new("/opt/game");
+    cmd.arg("--x").env("A", "1");
+    let out = wrap(cmd, &Launch::default());
+    assert_eq!(out.get_program(), "/opt/game");
+    assert_eq!(out.get_args().collect::<Vec<_>>(), ["--x"]);
+}
+
+#[cfg(unix)]
+#[test]
+fn the_wrapped_game_runs_after_its_pre_launch_command_in_its_folder() {
+    let dir = std::env::temp_dir().join(format!("horizon-launch-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let mut game = Command::new("/bin/sh");
+    // The "game" prints its words and two variables: one from the launcher, one the instance's.
+    game.args([
+        "-c",
+        "echo \"$1|$2|$FROM_LAUNCHER|$FROM_INSTANCE\"",
+        "game",
+        "a b",
+        "$HOME",
+    ])
+    .current_dir(&dir)
+    .env("FROM_LAUNCHER", "yes");
+    let launch = Launch {
+        pre_launch: "echo ran > pre.txt".into(),
+        wrapper: "/usr/bin/env WRAPPED=1".into(),
+        env: parse_env("FROM_INSTANCE=\"it works\"").unwrap(),
+        ..Launch::default()
+    };
+    let out = wrap(game, &launch).output().unwrap();
+    assert!(out.status.success(), "{out:?}");
+    assert_eq!(
+        String::from_utf8_lossy(&out.stdout),
+        "a b|$HOME|yes|it works\n"
+    );
+    assert_eq!(
+        std::fs::read_to_string(dir.join("pre.txt")).unwrap(),
+        "ran\n"
+    );
+
+    let failing = Launch {
+        pre_launch: "exit 3".into(),
+        ..Launch::default()
+    };
+    let mut game = Command::new("/bin/sh");
+    game.args(["-c", "echo started > started.txt"])
+        .current_dir(&dir);
+    let out = wrap(game, &failing).output().unwrap();
+    assert_eq!(out.status.code(), Some(3));
+    assert!(String::from_utf8_lossy(&out.stderr).contains("pre-launch command failed (exit 3)"));
+    assert!(!dir.join("started.txt").exists());
+    std::fs::remove_dir_all(&dir).unwrap();
+}
+
+#[test]
+fn the_linux_switches_act_only_where_their_tools_are() {
+    let all = Found {
+        gamemode: true,
+        mangohud: true,
+        two_gpus: true,
+        nvidia: false,
+    };
+    let launch = Launch {
+        wrapper: "nice".into(),
+        gamemode: true,
+        mangohud: true,
+        dedicated_gpu: true,
+        ..Launch::default()
+    };
+    assert_eq!(
+        plan(&launch, os(&["game"]), false, &all),
+        Plan::Direct(os(&["gamemoderun", "mangohud", "nice", "game"]))
+    );
+    assert_eq!(switch_env(&launch, &all), [("DRI_PRIME", "1")]);
+    let nvidia = Found {
+        nvidia: true,
+        ..all
+    };
+    assert_eq!(
+        switch_env(&launch, &nvidia),
+        [
+            ("__NV_PRIME_RENDER_OFFLOAD", "1"),
+            ("__VK_LAYER_NV_optimus", "NVIDIA_only"),
+            ("__GLX_VENDOR_LIBRARY_NAME", "nvidia")
+        ]
+    );
+    // Not installed (or not Linux): switched on, but nothing is added.
+    let none = Found::default();
+    assert_eq!(
+        plan(&launch, os(&["game"]), false, &none),
+        Plan::Direct(os(&["nice", "game"]))
+    );
+    assert!(switch_env(&launch, &none).is_empty());
+    assert!(!none.any() && all.any());
+    assert_eq!(
+        launch.summary().unwrap(),
+        "through nice, with GameMode, with MangoHud, on the dedicated GPU"
+    );
+    // Off switches aren't written.
+    let text = serde_json::to_string(&Launch::default()).unwrap();
+    assert_eq!(text, "{}");
+}
diff --git a/launcher/src/launch_page.rs b/launcher/src/launch_page.rs
new file mode 100644
index 000000000..4cfad986a
--- /dev/null
+++ b/launcher/src/launch_page.rs
@@ -0,0 +1,237 @@
+//! Launch… on Home's Instance row: what runs around the selected instance's game
+//! (`horizon_launcher::launch`): a command before it, a wrapper, and environment variables.
+use super::servers_page::Field;
+use super::*;
+use horizon_launcher::launch;
+
+pub(super) struct LaunchPanel {
+    /// The instance it is for: picking another closes it.
+    instance: String,
+    /// What Save did, or why not.
+    saved: Option<Result<String, String>>,
+    /// What this computer has for the Linux switches, looked at when the panel opens.
+    found: launch::Found,
+}
+
+/// A Linux switch: which one, its label, and what it does.
+#[derive(Clone, Copy)]
+enum Toggle {
+    GameMode,
+    MangoHud,
+    Gpu,
+}
+
+impl Launcher {
+    pub(super) fn toggle_launch(&mut self) {
+        if self.launch.take().is_some() {
+            return;
+        }
+        let Some(i) = self.selected_instance().cloned() else {
+            return;
+        };
+        *self.servers.text(Field::PreLaunch) = i.launch.pre_launch.clone();
+        *self.servers.text(Field::Wrapper) = i.launch.wrapper.clone();
+        *self.servers.text(Field::LaunchEnv) = launch::env_line(&i.launch.env);
+        self.launch = Some(LaunchPanel {
+            instance: i.id,
+            saved: None,
+            found: launch::Found::here(),
+        });
+    }
+
+    pub(super) fn save_launch(&mut self) {
+        let Some(id) = self.launch.as_ref().map(|p| p.instance.clone()) else {
+            return;
+        };
+        let pre = self.servers.value(Field::PreLaunch).trim().to_string();
+        let wrapper = self.servers.value(Field::Wrapper).trim().to_string();
+        let saved = launch::parse_env(self.servers.value(Field::LaunchEnv)).and_then(|env| {
+            instances::edit(&id, |m| {
+                m.launch = launch::Launch {
+                    pre_launch: pre,
+                    wrapper,
+                    env,
+                    ..m.launch.clone()
+                }
+            })
+        });
+        let saved = saved.map(|i| {
+            let said = match i.launch.summary() {
+                Some(what) => format!("Saved: the next Play {what}."),
+                None => "Saved: nothing runs around the game.".to_string(),
+            };
+            self.reload_instances();
+            said
+        });
+        if let Some(p) = &mut self.launch {
+            p.saved = Some(saved);
+        }
+    }
+
+    /// Flips a Linux switch, saved at once.
+    fn flip(&mut self, toggle: Toggle) {
+        let Some(panel) = &mut self.launch else {
+            return;
+        };
+        let saved = instances::edit(&panel.instance, |m| {
+            let on = match toggle {
+                Toggle::GameMode => &mut m.launch.gamemode,
+                Toggle::MangoHud => &mut m.launch.mangohud,
+                Toggle::Gpu => &mut m.launch.dedicated_gpu,
+            };
+            *on = !*on;
+        });
+        panel.saved = Some(saved.map(|i| match i.launch.summary() {
+            Some(what) => format!("Saved: the next Play {what}."),
+            None => "Saved: nothing runs around the game.".to_string(),
+        }));
+        self.reload_instances();
+    }
+
+    /// The Linux switches this computer can use: GameMode and MangoHud when installed, the
+    /// dedicated GPU with two cards.
+    fn linux_switches(&self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let found = self.launch.as_ref()?.found;
+        let now = self.selected_instance()?.launch.clone();
+        let gpu_about = match found.nvidia {
+            true => "NVIDIA render offload: __NV_PRIME_RENDER_OFFLOAD and its Vulkan layer.",
+            false => "Mesa's DRI_PRIME=1, so Vulkan picks the other card.",
+        };
+        let mut list = div().flex().flex_col().gap(px(10.));
+        for (toggle, shown, on, label, about) in [
+            (
+                Toggle::GameMode,
+                found.gamemode,
+                now.gamemode,
+                "GameMode",
+                "Feral's gamemoderun: CPU and scheduler tuned while you play.",
+            ),
+            (
+                Toggle::MangoHud,
+                found.mangohud,
+                now.mangohud,
+                "MangoHud",
+                "The frame time, CPU and GPU overlay.",
+            ),
+            (
+                Toggle::Gpu,
+                found.two_gpus,
+                now.dedicated_gpu,
+                "Dedicated graphics card",
+                gpu_about,
+            ),
+        ] {
+            if !shown {
+                continue;
+            }
+            list = list.child(
+                div()
+                    .id(SharedString::from(format!("launch-switch-{label}")))
+                    .flex()
+                    .items_center()
+                    .gap(px(10.))
+                    .cursor_pointer()
+                    .child(switch(
+                        SharedString::from(format!("launch-switch-{label}-s")),
+                        on,
+                        &t,
+                    ))
+                    .child(text(theme::LABEL).text_color(t.ink_soft).child(label))
+                    .child(text(theme::CAPTION).text_color(t.muted).child(about))
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        this.flip(toggle);
+                        cx.notify();
+                    })),
+            );
+        }
+        found.any().then(|| {
+            div()
+                .flex()
+                .flex_col()
+                .gap(px(8.))
+                .child(caps("On this computer").text_color(t.muted))
+                .child(list)
+        })
+    }
+
+    /// The panel under the Instance row, while open for the selected instance.
+    pub(super) fn launch_panel(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let selected = self.selected_instance().map(|i| i.id.clone());
+        if self.launch.as_ref().map(|p| &p.instance) != selected.as_ref() {
+            self.launch = None;
+        }
+        let saved = self.launch.as_ref()?.saved.clone();
+        let row = |this: &mut Self,
+                   cx: &mut Context<Self>,
+                   label: &'static str,
+                   field: Field,
+                   placeholder: &'static str,
+                   about: &'static str| {
+            div()
+                .flex()
+                .flex_col()
+                .gap(px(6.))
+                .child(caps(label).text_color(t.muted))
+                .child(this.field(field, placeholder, 520., cx))
+                .child(text(theme::CAPTION).text_color(t.muted).child(about))
+        };
+        let pre = row(
+            self,
+            cx,
+            "Before the game",
+            Field::PreLaunch,
+            "For example ./backup.sh",
+            "A shell command, run in the instance's folder. The game starts only if it succeeds.",
+        );
+        let wrapper = row(
+            self,
+            cx,
+            "Run the game through",
+            Field::Wrapper,
+            "For example nice -n 5",
+            "A program and its arguments; the game's command line goes after them.",
+        );
+        let env = row(
+            self,
+            cx,
+            "Environment variables",
+            Field::LaunchEnv,
+            "For example NAME=value OTHER=\"two words\"",
+            "For the game and both commands above.",
+        );
+        let save = button("launch-save", "Save", Kind::Secondary, &t).on_click(cx.listener(
+            |this, _: &ClickEvent, _, cx| {
+                this.save_launch();
+                cx.notify();
+            },
+        ));
+        let result = saved.map(|s| match s {
+            Ok(said) => text(theme::CAPTION).text_color(t.muted).child(said),
+            Err(e) => text(theme::CAPTION).text_color(t.danger).child(e),
+        });
+        Some(
+            plate(&t)
+                .flex()
+                .flex_col()
+                .gap(px(14.))
+                .px(px(14.))
+                .py(px(12.))
+                .ml(px(40.))
+                .child(caps("When it starts").text_color(t.muted))
+                .child(pre)
+                .child(wrapper)
+                .child(env)
+                .children(self.linux_switches(cx))
+                .child(
+                    div()
+                        .flex()
+                        .items_center()
+                        .gap(px(12.))
+                        .child(save)
+                        .children(result),
+                ),
+        )
+    }
+}
diff --git a/launcher/src/lib.rs b/launcher/src/lib.rs
index 3cba3ed10..43b28f42e 100644
--- a/launcher/src/lib.rs
+++ b/launcher/src/lib.rs
@@ -3,16 +3,31 @@ pub mod account;
 pub mod agents;
 pub mod backend;
 pub mod browser;
+pub mod datapacks;
 pub mod desktop;
+pub mod desktop_seams;
+pub mod export;
 #[cfg(unix)]
 pub mod game_app;
+pub mod game_log;
 pub mod heads;
+pub mod i18n;
+pub mod import;
+pub mod instances;
+pub mod launch;
 pub mod modpacks;
 pub mod mojang;
+pub mod packs;
 pub mod process;
 pub mod proxy;
+pub mod screenshots;
+pub mod server_list;
 pub mod servers;
+pub mod shortcut;
 pub mod signed;
+pub mod skins;
 pub mod sources;
 pub mod tailscale;
 pub mod telemetry;
+pub mod themes;
+pub mod worlds;
diff --git a/launcher/src/line_edit.rs b/launcher/src/line_edit.rs
new file mode 100644
index 000000000..2889eb5f1
--- /dev/null
+++ b/launcher/src/line_edit.rs
@@ -0,0 +1,678 @@
+//! The one-line text field every launcher input shares: the state (text, caret, selection,
+//! undo), the keyboard (`handle`) and what it draws (`content`). A page keeps its own box and
+//! its Enter/Escape; this is what is inside it. Positions count characters, not bytes.
+
+use super::*;
+use gpui::{
+    black, canvas, Bounds, Font, MouseButton, MouseDownEvent, MouseMoveEvent, Pixels, Point,
+    TextRun,
+};
+use std::{cell::RefCell, rc::Rc};
+
+/// What a key did to the field.
+#[derive(Debug, PartialEq)]
+pub(super) enum Key {
+    Enter,
+    Escape,
+    /// Not the field's: Tab (focus), shortcuts.
+    Pass,
+    /// The caret or the selection moved; the text is the same.
+    Moved,
+    /// The text changed.
+    Edited,
+    /// Ctrl/Cmd-V: `handle` inserts the clipboard's first line.
+    Paste,
+    /// Ctrl/Cmd-C: `handle` puts this on the clipboard.
+    Copy(String),
+    /// Ctrl/Cmd-X: the text changed; `handle` puts this on the clipboard.
+    Cut(String),
+}
+
+/// What the last edit was, so a run of typing undoes as one step.
+#[derive(Clone, Copy, PartialEq)]
+enum Run {
+    None,
+    Typing,
+    Deleting,
+    Other,
+}
+
+/// Where the text was drawn last frame, and how: what turns a mouse position into a character.
+struct Area {
+    bounds: Bounds<Pixels>,
+    font: Font,
+    size: Pixels,
+    mask: bool,
+}
+
+struct Snap {
+    text: String,
+    caret: usize,
+}
+
+pub(super) struct LineEdit {
+    text: String,
+    caret: usize,
+    /// The other end of the selection; equal to `caret` when nothing is selected.
+    anchor: usize,
+    scroll: usize,
+    max: usize,
+    /// How many characters the box shows.
+    visible: usize,
+    undo: Vec<Snap>,
+    redo: Vec<Snap>,
+    run: Run,
+    area: Rc<RefCell<Option<Area>>>,
+    /// A drag that started in this field is on.
+    dragging: bool,
+}
+
+const HISTORY: usize = 100;
+
+impl LineEdit {
+    pub(super) fn new(text: String, max: usize, visible: usize) -> Self {
+        let caret = text.chars().count();
+        let mut e = LineEdit {
+            text,
+            caret,
+            anchor: caret,
+            scroll: 0,
+            max,
+            visible,
+            undo: Vec::new(),
+            redo: Vec::new(),
+            run: Run::None,
+            area: Rc::default(),
+            dragging: false,
+        };
+        e.reveal();
+        e
+    }
+
+    pub(super) fn text(&self) -> &str {
+        &self.text
+    }
+
+    pub(super) fn select_all(&mut self) {
+        self.anchor = 0;
+        self.caret = self.len();
+    }
+
+    /// The character under `pos`, from where the text was drawn last frame.
+    fn index_at(&self, window: &Window, pos: Point<Pixels>) -> Option<usize> {
+        let area = self.area.borrow();
+        let a = area.as_ref()?;
+        let shown: String = self
+            .text
+            .chars()
+            .skip(self.scroll)
+            .take(self.visible)
+            .collect();
+        let shown = if a.mask {
+            "•".repeat(shown.chars().count())
+        } else {
+            shown
+        };
+        let run = TextRun {
+            len: shown.len(),
+            font: a.font.clone(),
+            color: black(),
+            background_color: None,
+            underline: None,
+            strikethrough: None,
+        };
+        let line = window
+            .text_system()
+            .shape_line(shown.clone().into(), a.size, &[run], None);
+        let at = line
+            .closest_index_for_x(pos.x - a.bounds.origin.x)
+            .min(shown.len());
+        Some(self.scroll + shown[..at].chars().count())
+    }
+
+    fn select_word(&mut self, at: usize) {
+        self.anchor = self.word(at, false);
+        self.caret = self.word(at, true).max(self.anchor);
+        self.run = Run::None;
+    }
+
+    fn len(&self) -> usize {
+        self.text.chars().count()
+    }
+
+    fn byte(&self, at: usize) -> usize {
+        self.text
+            .char_indices()
+            .nth(at)
+            .map_or(self.text.len(), |(i, _)| i)
+    }
+
+    fn range(&self) -> (usize, usize) {
+        (self.caret.min(self.anchor), self.caret.max(self.anchor))
+    }
+
+    fn selected(&self) -> String {
+        let (lo, hi) = self.range();
+        self.text.chars().skip(lo).take(hi - lo).collect()
+    }
+
+    fn snap(&self) -> Snap {
+        Snap {
+            text: self.text.clone(),
+            caret: self.caret,
+        }
+    }
+
+    /// Runs an edit and remembers the text it replaced for undo, unless it changed nothing
+    /// (typing a "t" over a selected "t") or continues a run. A run of typing is one step per
+    /// word: `split` starts a new one.
+    fn edit(&mut self, run: Run, split: bool, f: impl FnOnce(&mut Self)) {
+        let prev = self.snap();
+        let prev_run = self.run;
+        f(self);
+        if self.text == prev.text {
+            self.run = prev_run;
+            return;
+        }
+        if run == Run::Other || run != prev_run || split {
+            if self.undo.len() == HISTORY {
+                self.undo.remove(0);
+            }
+            self.undo.push(prev);
+        }
+        self.redo.clear();
+        self.run = run;
+    }
+
+    fn restore(&mut self, s: Snap) {
+        self.text = s.text;
+        self.caret = s.caret;
+        self.anchor = s.caret;
+        self.run = Run::None;
+    }
+
+    fn undo(&mut self) {
+        if let Some(s) = self.undo.pop() {
+            self.redo.push(self.snap());
+            self.restore(s);
+        }
+    }
+
+    fn redo(&mut self) {
+        if let Some(s) = self.redo.pop() {
+            self.undo.push(self.snap());
+            self.restore(s);
+        }
+    }
+
+    fn delete_selection(&mut self) -> bool {
+        let (lo, hi) = self.range();
+        if lo == hi {
+            return false;
+        }
+        self.text.replace_range(self.byte(lo)..self.byte(hi), "");
+        self.caret = lo;
+        self.anchor = lo;
+        true
+    }
+
+    fn put(&mut self, s: &str) {
+        self.delete_selection();
+        let room = self.max.saturating_sub(self.len());
+        let s: String = s.chars().filter(|c| !c.is_control()).take(room).collect();
+        self.text.insert_str(self.byte(self.caret), &s);
+        self.caret += s.chars().count();
+        self.anchor = self.caret;
+    }
+
+    /// Replaces the selection with `s` (control characters dropped), up to the length limit.
+    pub(super) fn insert(&mut self, s: &str) {
+        self.edit(Run::Other, false, |e| e.put(s));
+        self.reveal();
+    }
+
+    fn move_to(&mut self, at: usize, extend: bool) {
+        self.caret = at.min(self.len());
+        if !extend {
+            self.anchor = self.caret;
+        }
+        self.run = Run::None;
+    }
+
+    /// The start of the word before `from`, or the end of the one after it.
+    fn word(&self, from: usize, forward: bool) -> usize {
+        let chars: Vec<char> = self.text.chars().collect();
+        let mut i = from;
+        if forward {
+            while i < chars.len() && chars[i].is_whitespace() {
+                i += 1;
+            }
+            while i < chars.len() && !chars[i].is_whitespace() {
+                i += 1;
+            }
+        } else {
+            while i > 0 && chars[i - 1].is_whitespace() {
+                i -= 1;
+            }
+            while i > 0 && !chars[i - 1].is_whitespace() {
+                i -= 1;
+            }
+        }
+        i
+    }
+
+    /// Applies a key press. `command` is Ctrl, or Cmd on macOS.
+    pub(super) fn key(
+        &mut self,
+        key: &str,
+        key_char: Option<&str>,
+        command: bool,
+        shift: bool,
+    ) -> Key {
+        let (lo, hi) = self.range();
+        let out = match key {
+            "enter" => Key::Enter,
+            "escape" => Key::Escape,
+            "left" if !shift && lo != hi && !command => {
+                self.move_to(lo, false);
+                Key::Moved
+            }
+            "right" if !shift && lo != hi && !command => {
+                self.move_to(hi, false);
+                Key::Moved
+            }
+            "left" => {
+                let to = if command {
+                    self.word(self.caret, false)
+                } else {
+                    self.caret.saturating_sub(1)
+                };
+                self.move_to(to, shift);
+                Key::Moved
+            }
+            "right" => {
+                let to = if command {
+                    self.word(self.caret, true)
+                } else {
+                    self.caret + 1
+                };
+                self.move_to(to, shift);
+                Key::Moved
+            }
+            "home" => {
+                self.move_to(0, shift);
+                Key::Moved
+            }
+            "end" => {
+                self.move_to(self.len(), shift);
+                Key::Moved
+            }
+            "backspace" | "delete" => {
+                let run = if lo == hi { Run::Deleting } else { Run::Other };
+                self.edit(run, false, |e| {
+                    if !e.delete_selection() {
+                        let (from, to) = match (key, command) {
+                            ("backspace", false) => (e.caret.saturating_sub(1), e.caret),
+                            ("backspace", true) => (e.word(e.caret, false), e.caret),
+                            (_, false) => (e.caret, (e.caret + 1).min(e.len())),
+                            (_, true) => (e.caret, e.word(e.caret, true)),
+                        };
+                        e.anchor = from;
+                        e.caret = to;
+                        e.delete_selection();
+                    }
+                });
+                Key::Edited
+            }
+            "a" if command => {
+                self.select_all();
+                self.run = Run::None;
+                Key::Moved
+            }
+            "z" if command && shift => {
+                self.redo();
+                Key::Edited
+            }
+            "z" if command => {
+                self.undo();
+                Key::Edited
+            }
+            "y" if command => {
+                self.redo();
+                Key::Edited
+            }
+            "c" if command => Key::Copy(self.selected()),
+            "x" if command => {
+                let cut = self.selected();
+                self.edit(Run::Other, false, |e| {
+                    e.delete_selection();
+                });
+                Key::Cut(cut)
+            }
+            "v" if command => Key::Paste,
+            _ if command => Key::Pass,
+            // Not every platform gives Space a character.
+            "space" => {
+                let run = if lo == hi { Run::Typing } else { Run::Other };
+                self.edit(run, false, |e| e.put(" "));
+                Key::Edited
+            }
+            _ => match key_char {
+                Some(ch) if !ch.is_empty() && !ch.chars().any(char::is_control) => {
+                    let starts_word = !ch.starts_with(char::is_whitespace)
+                        && self
+                            .text
+                            .chars()
+                            .nth(self.caret.wrapping_sub(1))
+                            .is_some_and(char::is_whitespace);
+                    let run = if lo == hi { Run::Typing } else { Run::Other };
+                    self.edit(run, starts_word, |e| e.put(ch));
+                    Key::Edited
+                }
+                _ => Key::Pass,
+            },
+        };
+        self.reveal();
+        out
+    }
+
+    /// Scrolls the field so the caret shows.
+    fn reveal(&mut self) {
+        if self.caret < self.scroll {
+            self.scroll = self.caret;
+        } else if self.caret > self.scroll + self.visible {
+            self.scroll = self.caret - self.visible;
+        }
+    }
+
+    /// What shows: the text before the selection, the selection, the text after, and whether the
+    /// caret sits before the selection (otherwise after it). `whole` shows all of it selected.
+    fn view(&self, whole: bool) -> (String, String, String, bool) {
+        let (lo, hi) = if whole { (0, self.len()) } else { self.range() };
+        let end = self.scroll + self.visible;
+        let part = |a: usize, b: usize| -> String {
+            let (a, b) = (a.max(self.scroll), b.min(end));
+            self.text
+                .chars()
+                .skip(a)
+                .take(b.saturating_sub(a))
+                .collect()
+        };
+        (
+            part(0, lo),
+            part(lo, hi),
+            part(hi, usize::MAX),
+            self.caret == lo,
+        )
+    }
+}
+
+/// What a paste puts in a one-line field: the clipboard's first line, spaces at its ends kept
+/// (` --world Test` after an argument is a new argument).
+fn pasted(clipboard: &str) -> &str {
+    clipboard.lines().next().unwrap_or_default()
+}
+
+/// The keyboard in a field: moves the caret, edits, copies and pastes. Never returns Paste, Copy
+/// or Cut (they are done); Enter, Escape and Pass are the page's.
+pub(super) fn handle(edit: &mut LineEdit, ev: &KeyDownEvent, cx: &mut App) -> Key {
+    let k = &ev.keystroke;
+    let command = k.modifiers.control || k.modifiers.platform;
+    match edit.key(&k.key, k.key_char.as_deref(), command, k.modifiers.shift) {
+        Key::Paste => {
+            if let Some(text) = cx.read_from_clipboard().and_then(|c| c.text()) {
+                edit.insert(pasted(&text));
+            }
+            Key::Edited
+        }
+        Key::Copy(s) => {
+            cx.write_to_clipboard(gpui::ClipboardItem::new_string(s));
+            Key::Moved
+        }
+        Key::Cut(s) => {
+            cx.write_to_clipboard(gpui::ClipboardItem::new_string(s));
+            Key::Edited
+        }
+        other => other,
+    }
+}
+
+/// Puts mouse handling on a field's box: a click puts the caret in (Shift extends the selection),
+/// a drag selects, a double click selects a word and a triple click the line.
+pub(super) fn mouse<T: 'static, E: InteractiveElement>(
+    el: E,
+    cx: &mut Context<T>,
+    edit: impl Fn(&mut T) -> &mut LineEdit + Clone + 'static,
+) -> E {
+    let get = edit.clone();
+    el.on_mouse_down(
+        MouseButton::Left,
+        cx.listener(move |this, ev: &MouseDownEvent, window, cx| {
+            let e = get(this);
+            if let Some(at) = e.index_at(window, ev.position) {
+                match ev.click_count {
+                    1 => e.move_to(at, ev.modifiers.shift),
+                    2 => e.select_word(at),
+                    _ => e.select_all(),
+                }
+                e.dragging = true;
+                cx.notify();
+            }
+        }),
+    )
+    .on_mouse_move(cx.listener(move |this, ev: &MouseMoveEvent, window, cx| {
+        let e = edit(this);
+        if !ev.dragging() {
+            e.dragging = false;
+        } else if e.dragging {
+            if let Some(at) = e.index_at(window, ev.position) {
+                e.move_to(at, true);
+                cx.notify();
+            }
+        }
+    }))
+}
+
+/// What a field draws inside its box: the placeholder while empty and unfocused, else the text
+/// with its selection and caret. `mask` shows dots (a token); `whole` shows all selected.
+pub(super) fn content(
+    edit: &LineEdit,
+    t: &theme::Theme,
+    focused: bool,
+    whole: bool,
+    mask: bool,
+    placeholder: &'static str,
+) -> Div {
+    if edit.text.is_empty() && !focused {
+        return div().text_color(t.muted).child(placeholder);
+    }
+    let (before, selected, after, caret_first) = edit.view(whole);
+    let text = |s: String| {
+        let s = if mask {
+            "•".repeat(s.chars().count())
+        } else {
+            s
+        };
+        div().flex_none().whitespace_nowrap().child(s)
+    };
+    let caret = || div().flex_none().w(px(1.)).h(px(14.)).bg(t.ink);
+    let area = edit.area.clone();
+    div()
+        .relative()
+        .flex()
+        .items_center()
+        .text_color(t.ink)
+        .child(text(before))
+        .when(focused && caret_first, |d| d.child(caret()))
+        .when(!selected.is_empty(), |d| {
+            d.child(
+                text(selected)
+                    .rounded(px(2.))
+                    .bg(t.accent.opacity(theme::SELECTION)),
+            )
+        })
+        .when(focused && !caret_first, |d| d.child(caret()))
+        .child(text(after))
+        .child(
+            // Records where the text sits and in what font, for the mouse.
+            canvas(
+                move |bounds, window, _| {
+                    let style = window.text_style();
+                    *area.borrow_mut() = Some(Area {
+                        bounds,
+                        font: style.font(),
+                        size: style.font_size.to_pixels(window.rem_size()),
+                        mask,
+                    });
+                },
+                |_, _, _, _| {},
+            )
+            .absolute()
+            .size_full(),
+        )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn edit(text: &str) -> LineEdit {
+        LineEdit::new(text.into(), 1024, 38)
+    }
+
+    fn typed(e: &mut LineEdit, s: &str) {
+        for c in s.chars() {
+            let key = if c == ' ' { "space" } else { "x" };
+            let ch = c.to_string();
+            e.key(key, (c != ' ').then_some(ch.as_str()), false, false);
+        }
+    }
+
+    #[test]
+    fn spaces_type_and_the_caret_moves_and_edits_in_the_middle() {
+        let mut e = edit("");
+        typed(&mut e, "--name Steve");
+        assert_eq!(e.text(), "--name Steve");
+        for _ in 0..5 {
+            e.key("left", None, false, false);
+        }
+        typed(&mut e, "X");
+        assert_eq!(e.text(), "--name XSteve");
+        e.key("backspace", None, false, false);
+        e.key("delete", None, false, false);
+        assert_eq!(e.text(), "--name teve");
+        e.key("home", None, false, false);
+        e.key("delete", None, false, false);
+        assert_eq!(e.text(), "-name teve");
+    }
+
+    #[test]
+    fn undo_steps_back_a_run_at_a_time_and_redo_returns() {
+        let mut e = edit("");
+        typed(&mut e, "--name Steve");
+        e.key("home", None, false, false);
+        e.key("delete", None, false, false);
+        e.key("delete", None, false, false);
+        assert_eq!(e.text(), "name Steve");
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "--name Steve");
+        // Typing undoes a word at a time.
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "--name ");
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "");
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "");
+        e.key("y", None, true, false);
+        assert_eq!(e.text(), "--name ");
+        e.key("y", None, true, false);
+        assert_eq!(e.text(), "--name Steve");
+        e.key("z", None, true, false);
+        e.key("z", None, true, true);
+        assert_eq!(e.text(), "--name Steve");
+        // A paste is a step of its own, and typing after an undo drops the redo.
+        e.key("end", None, false, false);
+        e.insert("!");
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "--name Steve");
+        typed(&mut e, "?");
+        e.key("y", None, true, false);
+        assert_eq!(e.text(), "--name Steve?");
+    }
+
+    #[test]
+    fn selection_is_replaced_copied_and_cut() {
+        let mut e = edit("--name Steve");
+        e.key("a", None, true, false);
+        assert_eq!(
+            e.key("c", None, true, false),
+            Key::Copy("--name Steve".into())
+        );
+        e.key("home", None, false, false);
+        for _ in 0..2 {
+            e.key("right", None, false, true);
+        }
+        assert_eq!(e.key("x", None, true, false), Key::Cut("--".into()));
+        assert_eq!(e.text(), "name Steve");
+        e.key("a", None, true, false);
+        e.key("y", Some("y"), false, false);
+        assert_eq!(e.text(), "y");
+        e.insert("a\nb c");
+        assert_eq!(e.text(), "yab c");
+    }
+
+    #[test]
+    fn words_and_the_length_limit() {
+        let mut e = edit("one two three");
+        e.key("backspace", None, true, false);
+        assert_eq!(e.text(), "one two ");
+        e.key("left", None, true, false);
+        e.key("delete", None, true, false);
+        assert_eq!(e.text(), "one  ");
+        let mut e = LineEdit::new("abc".into(), 4, 38);
+        e.insert("defg");
+        assert_eq!(e.text(), "abcd");
+        assert_eq!(e.key("tab", None, false, false), Key::Pass);
+        assert_eq!(e.key("q", None, true, false), Key::Pass);
+        assert_eq!(e.key("enter", Some("\n"), false, false), Key::Enter);
+        assert_eq!(e.key("escape", None, false, false), Key::Escape);
+    }
+
+    #[test]
+    fn an_edit_that_changes_nothing_is_not_an_undo_step() {
+        let mut e = edit("test");
+        e.key("left", None, false, false);
+        e.key("end", None, false, false);
+        e.key("left", None, false, true);
+        e.key("t", Some("t"), false, false);
+        assert_eq!(e.text(), "test");
+        e.key("delete", None, false, false);
+        e.key("home", None, false, false);
+        e.key("backspace", None, false, false);
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "test");
+        e.insert("");
+        e.key("x", Some("x"), false, false);
+        assert_eq!(e.text(), "xtest");
+        e.key("z", None, true, false);
+        assert_eq!(e.text(), "test");
+    }
+
+    #[test]
+    fn a_selected_text_is_replaced_by_what_is_typed() {
+        let mut e = edit("My server");
+        e.select_all();
+        e.key("f", Some("F"), false, false);
+        assert_eq!(e.text(), "F");
+    }
+
+    #[test]
+    fn the_view_follows_the_caret() {
+        let mut e = edit(&"é".repeat(100));
+        let (before, sel, after, _) = e.view(false);
+        assert_eq!((before.chars().count(), sel.len(), after.len()), (38, 0, 0));
+        e.key("home", None, false, false);
+        assert_eq!(e.view(false).2.chars().count(), 38);
+        assert_eq!(e.view(true).1.chars().count(), 38);
+    }
+}
diff --git a/launcher/src/main.rs b/launcher/src/main.rs
index 50e62756d..1eeb1477c 100644
--- a/launcher/src/main.rs
+++ b/launcher/src/main.rs
@@ -10,20 +10,37 @@ mod cli;
 mod cli_tools;
 mod collection;
 mod console;
+mod console_page;
 mod cull;
+mod datapacks_page;
+mod export_page;
 mod game_tools;
+mod import_page;
+mod instances_page;
 mod internet;
+mod language_page;
+mod launch_page;
+mod line_edit;
 mod markdown;
 mod mcp;
 mod modpacks_page;
 mod mods_page;
 mod mods_project;
+mod multiplayer_page;
+mod packs_page;
 mod partner;
 mod perf;
+mod screenshots_page;
 mod scrollbar;
 mod servers_page;
+mod shortcut_page;
+mod skin_page;
+mod switch_page;
 mod theme;
+mod themes_page;
 mod titlebar;
+mod while_playing;
+mod worlds_page;
 
 use gpui::{
     actions, div, ease_out_quint, prelude::*, px, relative, size, Animation, AnimationExt,
@@ -33,6 +50,8 @@ use gpui::{
 };
 use horizon_launcher::account::{self, Accounts, SignIn, SignInState};
 use horizon_launcher::backend::{self, Job, Msg, Release, Running, Settings, Updates};
+use horizon_launcher::i18n::{self, tr, trf};
+use horizon_launcher::instances;
 use horizon_launcher::telemetry;
 use scrollbar::Scrollbar;
 use std::borrow::Cow;
@@ -59,7 +78,7 @@ impl Page {
     /// `settings`) opens on that page, for screenshots; Home otherwise.
     fn from_env() -> Page {
         match std::env::var("HORIZON_LAUNCHER_PAGE").as_deref() {
-            Ok("mods" | "modpacks" | "shaders") => Page::Mods,
+            Ok("mods" | "modpacks" | "shaders" | "datapacks") => Page::Mods,
             Ok("servers") => Page::Servers,
             Ok("versions") => Page::Versions,
             Ok("notes") => Page::Notes,
@@ -151,6 +170,12 @@ struct Launcher {
     install_error: Option<(String, String)>,
     confirm_remove: Option<String>,
     picker_open: bool,
+    /// The top bar's quick switch of who plays (`switch_page.rs`).
+    account_menu: bool,
+    /// Settings > Account's skin panel for an offline name (`skin_page.rs`).
+    skin: Option<skin_page::SkinPanel>,
+    /// Why the last picture for Home's background was refused.
+    background_error: Option<String>,
     settings: Settings,
     /// The Discord, sponsor and website links: built in until links.json on main has been read.
     links: backend::Links,
@@ -183,8 +208,12 @@ struct Launcher {
     friend_focused: bool,
     friend_focus: FocusHandle,
     joining: Option<String>,
+    /// Where the next start goes at once: `--world <folder>` or `--server <address>`.
+    quick_play: Option<(&'static str, String)>,
+    /// The instance the running game plays and when it started: its play time grows on exit.
+    client_run: Option<(String, Instant)>,
     /// Settings' Game arguments field: the line, whether it has focus, and its focus handle.
-    args_input: String,
+    args_input: line_edit::LineEdit,
     args_focused: bool,
     args_focus: FocusHandle,
     /// Settings' Proxy field, the same way (`proxy`).
@@ -222,6 +251,22 @@ struct Launcher {
     starting_pack: Option<std::path::PathBuf>,
     /// The Mods page: the browser's search, installs and updates (`mods_page.rs`).
     mods: mods_page::Mods,
+    /// The instances, for the sidebar and Play, and their dialog (`instances_page.rs`).
+    instances: instances_page::Instances,
+    /// Home's Worlds section, of the selected instance (`worlds_page.rs`).
+    worlds: worlds_page::Worlds,
+    multiplayer: multiplayer_page::Multiplayer,
+    screenshots: screenshots_page::Screenshots,
+    game_packs: packs_page::Packs,
+    world_packs: datapacks_page::WorldPacks,
+    export: Option<export_page::ExportPanel>,
+    launch: Option<launch_page::LaunchPanel>,
+    importing: import_page::Importing,
+    console: console_page::Console,
+    /// What the window did when the game started (`while_playing.rs`).
+    aside: while_playing::Aside,
+    /// The selected instance's desktop shortcut (`shortcut_page.rs`).
+    shortcuts: shortcut_page::Shortcuts,
     /// The name the game made up for an offline player (`horizon-player.txt`), for the top bar.
     offline_name: Option<String>,
     /// The player's servers, for the sidebar until the Servers page has read them.
@@ -236,7 +281,7 @@ impl Launcher {
     fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let (tx, rx) = channel();
         let appearance = cx.observe_window_appearance(window, |this, window, cx| {
-            this.theme = Theme::for_appearance(this.settings.appearance, window.appearance());
+            this.theme = this.settings_theme(window);
             cx.notify();
         });
         cx.spawn(async move |this, cx| loop {
@@ -248,7 +293,34 @@ impl Launcher {
             }
         })
         .detach();
+        // Counts the time the sidebar's partner banner is on screen, until it may be hidden.
+        cx.spawn(async move |this, cx| loop {
+            cx.background_executor()
+                .timer(Duration::from_secs(10))
+                .await;
+            let counting = this.update(cx, |this, cx| {
+                let s = &mut this.settings;
+                if s.partner_hidden || s.partner_seen_secs >= partner::SEEN_BEFORE_HIDE {
+                    return false;
+                }
+                if this.page != Page::Servers {
+                    s.partner_seen_secs += 10;
+                    if s.partner_seen_secs % 60 == 0
+                        || s.partner_seen_secs >= partner::SEEN_BEFORE_HIDE
+                    {
+                        s.save();
+                        cx.notify();
+                    }
+                }
+                true
+            });
+            if !matches!(counting, Ok(true)) {
+                break;
+            }
+        })
+        .detach();
         let mut settings = Settings::load();
+        i18n::set(settings.language());
         if settings.minecraft_dir.is_none() {
             settings.minecraft_dir = backend::default_minecraft_dir();
         }
@@ -276,7 +348,7 @@ impl Launcher {
         // `window.appearance()`, so both draw the same look.
         titlebar::apply_appearance(window, settings.appearance);
         let mut this = Self {
-            theme: Theme::for_appearance(settings.appearance, window.appearance()),
+            theme: Theme::for_appearance(settings.appearance, settings.accent, window.appearance()),
             page: Page::from_env(),
             switches: 0,
             content_scroll: Scrollbar::default(),
@@ -303,7 +375,10 @@ impl Launcher {
             install_error: None,
             confirm_remove: None,
             picker_open: false,
-            args_input: settings.game_args.clone(),
+            account_menu: false,
+            skin: None,
+            background_error: None,
+            args_input: line_edit::LineEdit::new(settings.game_args.clone(), 1024, 38),
             args_focused: false,
             args_focus: cx.focus_handle(),
             proxy_input: settings.proxy.clone().unwrap_or_default(),
@@ -331,6 +406,8 @@ impl Launcher {
             friend_focused: false,
             friend_focus: cx.focus_handle(),
             joining: None,
+            quick_play: None,
+            client_run: None,
             collection: collection::Collection::load(),
             agents: agents_page::AgentsUi::default(),
             playing: None,
@@ -352,11 +429,24 @@ impl Launcher {
             pack_error: None,
             starting_pack: None,
             mods: mods_page::Mods::new(cx),
+            instances: instances_page::Instances::default(),
+            worlds: worlds_page::Worlds::default(),
+            multiplayer: multiplayer_page::Multiplayer::default(),
+            screenshots: screenshots_page::Screenshots::default(),
+            game_packs: packs_page::Packs::default(),
+            world_packs: datapacks_page::WorldPacks::default(),
+            export: None,
+            launch: None,
+            importing: Default::default(),
+            console: Default::default(),
+            aside: while_playing::Aside::new(window.window_handle()),
+            shortcuts: Default::default(),
             offline_name: offline_name(),
             side_servers: horizon_launcher::servers::list(),
             art: art::Art::default(),
             scale: window.scale_factor(),
         };
+        this.reload_instances();
         if this.bench.is_some() {
             this.perf.keep_local_log(false);
         }
@@ -393,6 +483,7 @@ impl Launcher {
             }
         }
         self.picker_open = false;
+        self.account_menu = false;
     }
 
     fn check_updates(&mut self) {
@@ -509,23 +600,55 @@ impl Launcher {
                             Err(e) => self.client_error = Some(format!("Playing offline: {e}")),
                         }
                         self.accounts = Accounts::load();
-                        if let Some(work) = self.starting_pack.take() {
-                            if let Err(e) =
-                                horizon_launcher::modpacks::apply_profile(&mut cmd, &work)
-                            {
-                                self.client_error = Some(e);
-                                continue;
+                        // An offline name the player picked (the quick switch).
+                        if let Some(name) = self.accounts.name_arg() {
+                            cmd.arg("--name").arg(name);
+                        }
+                        cmd.envs(self.accounts.look_env());
+                        // A pack's Play button plays that pack; Play plays the selected instance.
+                        let (profile, run) = match self.starting_pack.take() {
+                            Some(work) => {
+                                let id = instances::list()
+                                    .into_iter()
+                                    .find(|i| i.work == work)
+                                    .map(|i| i.id);
+                                let applied =
+                                    horizon_launcher::modpacks::apply_profile(&mut cmd, &work);
+                                (applied, id)
                             }
+                            None => {
+                                let instance = instances::selected();
+                                (instances::apply(&mut cmd, &instance), Some(instance.id))
+                            }
+                        };
+                        if let Err(e) = profile {
+                            self.client_error = Some(e);
+                            continue;
                         }
                         if let Some(code) = self.joining.take() {
                             if let Err(e) = backend::join_friend(&mut cmd, &code) {
                                 self.client_error = Some(e);
                             }
                         }
+                        if let Some((flag, value)) = self.quick_play.take() {
+                            cmd.arg(flag).arg(value);
+                        }
                         backend::append_game_args(&mut cmd);
+                        // Last, around every argument: the instance's pre-launch command,
+                        // wrapper and variables.
+                        let launch = run
+                            .as_ref()
+                            .and_then(|id| instances::list().into_iter().find(|i| &i.id == id))
+                            .map(|i| i.launch)
+                            .unwrap_or_default();
+                        let cmd = horizon_launcher::launch::wrap(cmd, &launch);
                         self.client_home = cmd.get_current_dir().map(|d| d.to_path_buf());
                         match backend::spawn(Job::Client, cmd, self.tx.clone()) {
-                            Ok(r) => self.client = Some(r),
+                            Ok(r) => {
+                                self.client = Some(r);
+                                self.client_run = run.map(|id| (id, Instant::now()));
+                                self.step_aside(cx);
+                            }
                             Err(e) => self.client_error = Some(e),
                         }
                     }
@@ -642,10 +765,24 @@ impl Launcher {
                         }
                         Job::Client => {
                             self.client = None;
+                            self.come_back(cx);
+                            // The game saved: last played, sizes and pictures changed.
+                            self.worlds.stale();
+                            self.multiplayer.stale();
+                            self.screenshots.stale();
+                            self.game_packs.stale();
+                            if let Some((id, started)) = self.client_run.take() {
+                                if let Err(e) = instances::record_play(&id, started.elapsed()) {
+                                    eprintln!("Play time not saved: {e}");
+                                }
+                                self.reload_instances();
+                            }
+                            // The run's own game folder: an instance's or a pack's keeps its reports.
+                            let home = self.client_home.clone().unwrap_or_else(backend::game_home);
                             let report = self
                                 .client_started
                                 .take()
-                                .and_then(backend::crash_report_since);
+                                .and_then(|since| backend::crash_report_since(&home, since));
                             if error.is_some() && report.is_none() && self.switched_to_dx12() {
                                 self.client_error = Some(
                                     "Horizon's Vulkan renderer crashed while starting on this \
@@ -727,7 +864,15 @@ impl Launcher {
         switched
     }
 
+    /// The version Play starts: the selected instance's own, else the launcher's.
     fn selected(&self) -> Option<&String> {
+        self.selected_instance()
+            .and_then(|i| self.version_of(i))
+            .or_else(|| self.launcher_version())
+    }
+
+    /// The launcher's version: what instances without one of their own play.
+    fn launcher_version(&self) -> Option<&String> {
         self.settings
             .selected
             .as_ref()
@@ -1054,6 +1199,8 @@ fn button(
     t: &Theme,
 ) -> Stateful<Div> {
     let id: SharedString = id.into();
+    let label: SharedString = label.into();
+    let label = SharedString::from(tr(&label).to_string());
     let t = *t;
     let hover = match kind {
         Kind::Primary => t.on_face.opacity(0.10),
@@ -1097,16 +1244,33 @@ fn button(
             .items_center()
             .gap(px(8.))
             .pb(px(if kind == Kind::Ghost { 0. } else { 2. }))
-            .child(label.into()),
+            .child(label),
     );
     keyboard(track_hover(base, id), &t).active(|s| s.opacity(theme::PRESSED).top(px(1.)))
 }
 
+/// Copies to the clipboard, or into `HORIZON_LAUNCHER_CLIPBOARD` when a test run sets it
+/// (`horizon_launcher::desktop_seams`).
+fn copy_to_clipboard(cx: &mut App, item: gpui::ClipboardItem) {
+    let Some(file) = horizon_launcher::desktop_seams::clipboard_file() else {
+        cx.write_to_clipboard(item);
+        return;
+    };
+    let bytes = match item.entries().first() {
+        Some(gpui::ClipboardEntry::Image(image)) => image.bytes.clone(),
+        _ => item.text().unwrap_or_default().into_bytes(),
+    };
+    if let Err(e) = std::fs::write(&file, bytes) {
+        eprintln!("{}: {e}", file.display());
+    }
+}
+
 /// An on/off switch: a square knob sliding in a sunk track that turns violet when on.
-fn switch(id: &'static str, on: bool, t: &Theme) -> Stateful<Div> {
+fn switch(id: impl Into<SharedString>, on: bool, t: &Theme) -> Stateful<Div> {
     let t = *t;
+    let id: SharedString = id.into();
     let knob = if on { t.on_face } else { t.muted };
-    keyboard(div().id(id), &t)
+    keyboard(div().id(id.clone()), &t)
         .relative()
         .flex_none()
         .w(px(44.))
@@ -1148,7 +1312,7 @@ fn section_title(label: &'static str, icon: &'static str, t: &Theme) -> Div {
         .child(
             blocks::pixel(18., FontWeight::SEMIBOLD)
                 .text_color(t.ink)
-                .child(label),
+                .child(tr(label)),
         )
 }
 
@@ -1194,7 +1358,7 @@ fn segments<T: Copy + PartialEq + 'static>(
                 .when(!active, |d| {
                     d.text_color(t.muted).hover(move |s| s.text_color(t.ink))
                 })
-                .child(div().relative().child(label))
+                .child(div().relative().child(tr(label)))
                 .on_click(move |_: &ClickEvent, window, cx| pick(value, window, cx))
         }))
 }
@@ -1220,13 +1384,13 @@ fn page_header(title: &str, description: &str, t: &Theme) -> Div {
         .child(
             blocks::pixel(36., FontWeight::SEMIBOLD)
                 .text_color(t.ink)
-                .child(title.to_string()),
+                .child(tr(title).to_string()),
         )
         .child(
             text(theme::UI)
                 .max_w(px(520.))
                 .text_color(t.muted)
-                .child(description.to_string()),
+                .child(tr(description).to_string()),
         )
 }
 
@@ -1369,9 +1533,9 @@ fn megabytes(bytes: u64) -> String {
 // ----- Pages -------------------------------------------------------------------------------------
 
 impl Launcher {
-    /// The top bar: the mark and the name over the sidebar (in the title bar on Windows), the
-    /// pages with their icons, then the account playing and the Settings button.
-    fn topbar(&mut self, cx: &mut Context<Self>) -> Div {
+    /// The top bar: the mark and name over the sidebar (in the title bar on Windows and Linux
+    /// client-side decorations), the pages with their icons, then the account and Settings.
+    fn topbar(&mut self, window: &Window, cx: &mut Context<Self>) -> Div {
         let t = self.theme;
         let mut nav = div().flex().flex_none().h_full().gap(px(2.));
         for (page, label, icon) in Page::ALL {
@@ -1409,7 +1573,7 @@ impl Launcher {
                     blocks::pixel(16., FontWeight::MEDIUM)
                         .relative()
                         .text_color(if active { t.ink } else { t.muted })
-                        .child(label),
+                        .child(tr(label)),
                 )
                 .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
                     this.go(page);
@@ -1417,14 +1581,9 @@ impl Launcher {
                 }));
             nav = nav.child(keyboard(track_hover(item, id), &t));
         }
-        // Only a signed-in account says "Microsoft account"; otherwise the name the game made up.
-        let (name, how) = match self.accounts.selected() {
-            Some(a) => (a.name.clone(), "Microsoft account"),
-            None => (
-                self.offline_name.clone().unwrap_or_else(|| "Player".into()),
-                "Offline",
-            ),
-        };
+        // Only a signed-in account says "Microsoft account"; otherwise an offline name, or the
+        // one the game made up.
+        let (name, how) = self.who_plays();
         let account = keyboard(div().id("account"), &t)
             .relative()
             .flex()
@@ -1463,9 +1622,13 @@ impl Launcher {
                     .child(text(theme::CAPTION).text_color(t.muted).child(how)),
             )
             .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
-                this.go(Page::Settings);
+                this.account_menu = !this.account_menu;
                 cx.notify();
             }));
+        let account = div()
+            .relative()
+            .child(account)
+            .children(self.account_menu(cx));
         let settings_open = self.page == Page::Settings;
         let settings = keyboard(div().id("nav-Settings"), &t)
             .relative()
@@ -1508,8 +1671,8 @@ impl Launcher {
             .bg(t.side)
             .border_b_2()
             .border_color(t.outline)
-            // Where the title bar is drawn here (Windows), it carries the mark and the name.
-            .when(!titlebar::DRAWN, |bar| {
+            // Custom title bars carry the mark and name above the sidebar.
+            .when(!titlebar::draws_brand(window), |bar| {
                 bar.child(
                     div()
                         .flex()
@@ -1540,10 +1703,10 @@ impl Launcher {
 
     /// The sidebar: Horizon and the imported modpacks, the player's servers, then the
     /// launcher's own update, the community links and its version.
-    fn sidebar(&mut self, cx: &mut Context<Self>) -> Stateful<Div> {
+    fn sidebar(&mut self, window: &Window, cx: &mut Context<Self>) -> Stateful<Div> {
         let t = self.theme;
         self.load_packs();
-        let heading = |label: &'static str| {
+        let heading = |label: String| {
             div()
                 .flex()
                 .items_center()
@@ -1574,7 +1737,7 @@ impl Launcher {
                 .border_2()
                 .border_color(t.side)
         };
-        let add = keyboard(div().id("add-pack"), &t)
+        let add = keyboard(div().id("add-instance"), &t)
             .flex()
             .items_center()
             .justify_center()
@@ -1586,80 +1749,28 @@ impl Launcher {
             .hover(move |s| s.bg(t.raised))
             .child(blocks::icon("plus", 14., t.ink_soft))
             .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
-                this.show_modpack(None);
+                this.open_instance_dialog(None);
                 cx.notify();
             }));
-        let mut list = div()
+        let items = self.instance_items(heading, cx);
+        let mut rows = items.len();
+        let list = div()
             .flex()
             .flex_col()
             .gap(px(4.))
-            .child(heading("INSTANCES").child(add));
-        // Horizon itself, with a grass block from the player's own prepared files.
-        let tag = self.selected().cloned();
-        let prepared = tag.as_deref().is_some_and(backend::is_prepared);
-        let grass = self.vanilla_icon();
-        let on_play = self.page == Page::Play;
-        list = list.child(
-            blocks::side_item("side-horizon".into(), on_play, &t)
-                .child(match grass {
-                    Some(g) => div()
-                        .flex()
-                        .items_center()
-                        .justify_center()
-                        .size(px(44.))
-                        .child(gpui::img(g).size(px(40.))),
-                    None => blocks::slot(None, "Horizon", 44., &t),
-                })
-                .child(dot(if prepared { t.success } else { t.warn }))
-                .child(
-                    div()
-                        .flex()
-                        .flex_col()
-                        .min_w_0()
-                        .child(title("Horizon".into()))
-                        .child(sub(if tag.is_none() {
-                            "No version installed"
-                        } else if prepared {
-                            "Vanilla · ready"
-                        } else {
-                            "Needs preparing"
-                        }
-                        .into())),
-                )
-                .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
-                    this.go(Page::Play);
-                    cx.notify();
-                })),
-        );
-        let on_packs = self.page == Page::Mods && self.mods.on_modpacks();
-        for p in &self.packs {
-            let slug = p.slug.clone();
-            let open = on_packs && self.pack_open.as_ref() == Some(&p.slug);
-            list = list.child(
-                blocks::side_item(format!("side-pack-{slug}").into(), open, &t)
-                    .child(blocks::slot(None, p.title(), 44., &t))
-                    .child(
-                        div()
-                            .flex()
-                            .flex_col()
-                            .min_w_0()
-                            .child(title(p.title().to_string()))
-                            .child(sub(p.summary())),
-                    )
-                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
-                        this.show_modpack(Some(slug.clone()));
-                        cx.notify();
-                    })),
-            );
-        }
+            .child(heading(tr("INSTANCES").into()).child(add))
+            .children(items);
         let servers: Vec<_> = self
             .servers
             .sidebar_list()
             .map(<[_]>::to_vec)
             .unwrap_or_else(|| self.side_servers.clone());
+        let mut list = list;
         if !servers.is_empty() {
-            list = list.child(heading("SERVERS"));
+            list = list.child(heading(tr("SERVERS").into()));
         }
+        rows += servers.len();
+        let headings = 1 + usize::from(!servers.is_empty());
         for e in servers {
             let up = self.servers.is_up(&e.dir);
             let open = self.page == Page::Servers && self.servers.open.as_ref() == Some(&e.dir);
@@ -1684,7 +1795,7 @@ impl Launcher {
                             .flex_col()
                             .min_w_0()
                             .child(title(e.name.clone()))
-                            .child(sub(if up { "Running" } else { "Stopped" }.into())),
+                            .child(sub(tr(if up { "Running" } else { "Stopped" }).into())),
                     )
                     .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
                         this.servers.open = Some(dir.clone());
@@ -1749,6 +1860,44 @@ impl Launcher {
             }
             _ => {}
         }
+        // Sculk's card above the links: seen without scrolling, on every page but Servers, which shows
+        // its wide banner. Tall where the sidebar has the height for it besides its rows (about 60
+        // high each, under headings of about 40) and the links, compact otherwise. After a while on
+        // screen a "Hide" beside its label puts it away for good.
+        if self.page != Page::Servers && !self.settings.partner_hidden {
+            let free = f32::from(window.viewport_size().height)
+                - theme::TOPBAR
+                - 40. * headings as f32
+                - 60. * rows as f32
+                - 110.;
+            let mut side = div().relative().mb(px(8.)).child(partner::card(
+                "partner-side",
+                theme::SIDEBAR - 20.,
+                free < partner::TALL_HEIGHT,
+                &t,
+            ));
+            if self.settings.partner_seen_secs >= partner::SEEN_BEFORE_HIDE {
+                let hide = div()
+                    .id("partner-hide")
+                    .absolute()
+                    .top(px(0.))
+                    .right(px(0.))
+                    .cursor_pointer()
+                    .child(
+                        text(theme::MICRO)
+                            .text_color(t.muted)
+                            .hover(move |s| s.text_color(t.ink))
+                            .child(tr("HIDE")),
+                    )
+                    .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                        this.settings.partner_hidden = true;
+                        this.settings.save();
+                        cx.notify();
+                    }));
+                side = side.child(keyboard(hide, &t));
+            }
+            foot = foot.child(side);
+        }
         if !self.links.discord.is_empty() {
             foot = foot.child(link(
                 "discord",
@@ -1760,7 +1909,7 @@ impl Launcher {
         if !self.links.website.is_empty() {
             foot = foot.child(link(
                 "website",
-                "Website",
+                tr("Website"),
                 "globe",
                 self.links.website.clone(),
             ));
@@ -1839,16 +1988,20 @@ impl Launcher {
                 .absolute()
                 .top(px(66.))
                 .right_0()
-                .w(px(240.))
+                .w(px(300.))
                 .p(px(6.))
                 .border_2()
                 .border_color(t.outline)
                 .bg(t.surface)
                 .flex()
                 .flex_col();
+            // Picking a version keeps the selected instance on it; the launcher's own version
+            // (newest unless chosen otherwise on Versions) follows updates.
+            let follows = self.launcher_version().cloned();
             for tag in &self.installed {
                 let selected = self.selected() == Some(tag);
                 let tag = tag.clone();
+                let latest = follows.as_ref() == Some(&tag);
                 menu = menu.child(
                     div()
                         .id(SharedString::from(format!("pick-{tag}")))
@@ -1864,12 +2017,20 @@ impl Launcher {
                         .cursor_pointer()
                         .hover(move |s| s.bg(t.plate_soft))
                         .child(tag.clone())
-                        .when(selected, |d| {
-                            d.child(div().size(px(6.)).rounded_full().bg(t.accent))
-                        })
+                        .child(
+                            div()
+                                .flex()
+                                .items_center()
+                                .gap(px(8.))
+                                .when(latest, |d| {
+                                    d.child(caps("follows updates").text_color(t.muted))
+                                })
+                                .when(selected, |d| {
+                                    d.child(div().size(px(6.)).rounded_full().bg(t.accent))
+                                }),
+                        )
                         .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
-                            this.settings.selected = Some(tag.clone());
-                            this.settings.save();
+                            this.pin_version((!latest).then(|| tag.clone()));
                             this.picker_open = false;
                             cx.notify();
                         })),
@@ -1913,7 +2074,7 @@ impl Launcher {
                     "Start the game, or run a server for others to join.",
                     &t,
                 ))
-                .child(centered("No version installed yet.", &t).child(
+                .child(centered(tr("No version installed yet."), &t).child(
                     button("go-versions", "Choose a version", Kind::Secondary, &t).on_click(
                         cx.listener(|this, _: &ClickEvent, _, cx| {
                             this.go(Page::Versions);
@@ -1929,10 +2090,12 @@ impl Launcher {
         let hero = self.hero(&tag, &version, prepared, cx);
         let running = self.client.is_some() || self.starting_client.is_some();
         let play_label = if running { "Running" } else { "Play" };
+        // The label clears the icon in every language ("Играть" is wider than "Play").
         let mut play = button("play", play_label, Kind::Primary, &t)
             .min_w(px(200.))
             .h(px(60.))
-            .px(px(28.))
+            .pl(px(60.))
+            .pr(px(28.))
             .text_size(px(28.))
             .font_weight(FontWeight::SEMIBOLD)
             .child(
@@ -1973,7 +2136,7 @@ impl Launcher {
             );
 
         let resources_value = if self.preparing {
-            "Preparing…".to_string()
+            tr("Preparing…").to_string()
         } else {
             backend::resources_summary(prepared, !silent, &version)
         };
@@ -1998,7 +2161,9 @@ impl Launcher {
         let minecraft = self.settings.minecraft_dir.as_deref().map_or_else(
             || {
                 div()
-                    .child("Not found. Choose the folder where your launcher keeps Minecraft.")
+                    .child(tr(
+                        "Not found. Choose the folder where your launcher keeps Minecraft.",
+                    ))
                     .into_any_element()
             },
             |p| {
@@ -2012,16 +2177,19 @@ impl Launcher {
             .flex()
             .flex_col()
             .child(section_title("Ready to play", "check", &t).mb(px(12.)))
+            .children(self.instance_row(1, cx))
+            .children(self.export_panel(cx))
+            .children(self.launch_panel(cx))
             .child(index_row(
-                1,
-                "Resources",
+                2,
+                tr("Resources"),
                 Some(div().child(resources_value).into_any_element()),
                 Some(prepare.into_any_element()),
                 &t,
             ))
             .child(index_row(
-                2,
-                "Minecraft folder",
+                3,
+                tr("Minecraft folder"),
                 Some(minecraft),
                 Some(
                     button("choose-mc", "Choose…", Kind::Ghost, &t)
@@ -2036,11 +2204,11 @@ impl Launcher {
             // offline, in a build that can sign in.
             if self.accounts.selected().is_none() && account::client_id().is_some() {
                 rows = rows.child(index_row(
-                    4,
-                    "Playing offline",
+                    5,
+                    tr("Playing offline"),
                     Some(
                         div()
-                            .child("Online servers need a Microsoft account.")
+                            .child(tr("Online servers need a Microsoft account."))
                             .into_any_element(),
                     ),
                     Some(
@@ -2071,6 +2239,21 @@ impl Launcher {
                     gpui::linear_color_stop(t.page.opacity(to), at),
                 ))
         };
+        let picture = self.home_background();
+        let scene = match picture {
+            Some(path) => gpui::img(path)
+                .absolute()
+                .top_0()
+                .left_0()
+                .size_full()
+                .object_fit(gpui::ObjectFit::Cover),
+            None => gpui::img(scene)
+                .absolute()
+                .bottom_0()
+                .left_0()
+                .w(px(scene_width))
+                .h(px(art::SCENE_HEIGHT as f32 * art::SCENE_TEXEL)),
+        };
         let banner = div()
             .relative()
             .flex()
@@ -2085,14 +2268,7 @@ impl Launcher {
             .bg(gpui::rgb(art::sky_top(t.dark)))
             .border_b_2()
             .border_color(t.outline)
-            .child(
-                gpui::img(scene)
-                    .absolute()
-                    .bottom_0()
-                    .left_0()
-                    .w(px(scene_width))
-                    .h(px(art::SCENE_HEIGHT as f32 * art::SCENE_TEXEL)),
-            )
+            .child(scene)
             .child(veil(90., 0.82, 0., 0.62))
             .child(veil(180., 0., 0.75, 1.))
             .child(div().relative().child(hero))
@@ -2117,7 +2293,7 @@ impl Launcher {
                     .child(
                         text(theme::CAPTION)
                             .text_color(t.muted)
-                            .child("The first preparation takes a few minutes."),
+                            .child(tr("The first preparation takes a few minutes.")),
                     ),
             );
         }
@@ -2125,14 +2301,28 @@ impl Launcher {
             page = page.child(notice(e, &t));
         }
         page = page.child(rows);
+        if let Some(console) = self.console_section(cx) {
+            page = page.child(console);
+        }
+        if let Some(worlds) = self.worlds_section(cx) {
+            page = page.child(worlds);
+        }
+        if let Some(servers) = self.multiplayer_section(cx) {
+            page = page.child(servers);
+        }
+        if let Some(packs) = self.packs_section(cx) {
+            page = page.child(packs);
+        }
+        if let Some(shots) = self.screenshots_section(cx) {
+            page = page.child(shots);
+        }
         if let Some(e) = self.client_error.clone() {
             page = page.child(notice(e, &t));
         }
         if let Some(crash) = self.crash.clone() {
             page = page.child(self.crash_notice(crash, cx));
         }
-        // Below everything the player needs to start, so it never moves Play.
-        page.child(partner::banner("partner-home", 560., &t))
+        page
     }
 
     /// "Horizon crashed": the report and the logs, and where to report it.
@@ -2162,7 +2352,7 @@ impl Launcher {
                     .on_click(cx.listener(
                         move |this, _: &ClickEvent, _, cx| {
                             if let Ok(text) = std::fs::read_to_string(&report) {
-                                cx.write_to_clipboard(gpui::ClipboardItem::new_string(text));
+                                copy_to_clipboard(cx, gpui::ClipboardItem::new_string(text));
                                 if let Some(c) = &mut this.crash {
                                     c.copied = true;
                                 }
@@ -2197,11 +2387,11 @@ impl Launcher {
                 },
             )),
         );
-        let help = if crash.report.is_some() {
+        let help = tr(if crash.report.is_some() {
             "When you report it on Discord, attach the crash report file (or paste it with Copy report) and say what you were doing."
         } else {
             "The game ended without a crash report. When you report it on Discord, attach latest.log from the logs folder and say what you were doing."
-        };
+        });
         let mut body = div()
             .flex_1()
             .min_w_0()
@@ -2211,7 +2401,7 @@ impl Launcher {
             .child(
                 text(theme::HEADING)
                     .text_color(t.ink)
-                    .child("Horizon crashed"),
+                    .child(tr("Horizon crashed")),
             );
         if !crash.summary.is_empty() {
             body = body.child(div().text_color(t.ink_soft).child(crash.summary));
@@ -2287,7 +2477,7 @@ impl Launcher {
                             .child(caps(format!("Minecraft {version}")).text_color(t.ink_soft))
                             .child(div().size(px(4.)).bg(t.muted))
                             .child(
-                                caps(if prepared { "Ready" } else { "Needs preparing" })
+                                caps(tr(if prepared { "Ready" } else { "Needs preparing" }))
                                     .text_color(if prepared { t.success } else { t.warn }),
                             ),
                     )
@@ -2425,10 +2615,10 @@ impl Launcher {
             }),
         );
         let horizon = match (&self.updates.horizon, &self.update_error) {
-            (Some(r), _) => format!("{} available", r.tag),
+            (Some(r), _) => trf("{version} available", &[("version", &r.tag)]),
             (None, Some(e)) => e.clone(),
-            (None, None) if self.checked.is_some() => "Up to date".to_string(),
-            _ => "Checking…".to_string(),
+            (None, None) if self.checked.is_some() => tr("Up to date").to_string(),
+            _ => tr("Checking…").to_string(),
         };
         let horizon_action = self
             .updates
@@ -2445,18 +2635,36 @@ impl Launcher {
             });
         let launcher = match &self.self_update {
             SelfUpdate::Downloading(v, p) => {
-                format!("{}  ·  downloading {v}, {:.0}%", backend::VERSION, p * 100.)
+                let done = format!("{:.0}", p * 100.);
+                let said = trf(
+                    "downloading {version}, {percent}%",
+                    &[("version", v), ("percent", &done)],
+                );
+                format!("{}  ·  {said}", backend::VERSION)
             }
-            SelfUpdate::Ready(v) => format!("Updated to {v}. Restart the launcher to use it."),
-            SelfUpdate::Failed(e) => format!("{}  ·  the update failed: {e}", backend::VERSION),
+            SelfUpdate::Ready(v) => trf(
+                "Updated to {version}. Restart the launcher to use it.",
+                &[("version", v)],
+            ),
+            SelfUpdate::Failed(e) => format!(
+                "{}  ·  {}",
+                backend::VERSION,
+                trf("the update failed: {error}", &[("error", e)])
+            ),
             SelfUpdate::Idle => match &self.updates.launcher {
                 Some(r) => format!(
-                    "{}  ·  {} available",
+                    "{}  ·  {}",
                     backend::VERSION,
-                    backend::launcher_version(&r.tag).unwrap_or_default()
+                    trf(
+                        "{version} available",
+                        &[(
+                            "version",
+                            backend::launcher_version(&r.tag).unwrap_or_default()
+                        )]
+                    )
                 ),
                 None if self.checked.is_some() && self.update_error.is_none() => {
-                    format!("{}  ·  up to date", backend::VERSION)
+                    format!("{}  ·  {}", backend::VERSION, tr("up to date"))
                 }
                 None => backend::VERSION.to_string(),
             },
@@ -2481,8 +2689,9 @@ impl Launcher {
             ),
         };
         let mono = |s: String| div().font_family(theme::MONO).child(s).into_any_element();
-        let plain = |s: &str| div().child(s.to_string()).into_any_element();
+        let plain = |s: &str| div().child(tr(s).to_string()).into_any_element();
         let (accounts, n) = self.account_rows(cx);
+        let (offline, n) = self.offline_rows(n, cx);
         let appearance = segments(
             "appearance",
             &[
@@ -2499,7 +2708,7 @@ impl Launcher {
                         this.settings.appearance = choice;
                         this.settings.save();
                         titlebar::apply_appearance(window, choice);
-                        this.theme = Theme::for_appearance(choice, window.appearance());
+                        this.theme = this.settings_theme(window);
                         cx.notify();
                     });
                 }
@@ -2523,10 +2732,11 @@ impl Launcher {
                     .flex_col()
                     .child(group("Account", "user").mt_0())
                     .child(accounts)
+                    .child(offline)
                     .child(group("Updates", "reload"))
                     .child(index_row(
                         n + 1,
-                        "Install new versions automatically",
+                        tr("Install new versions automatically"),
                         Some(plain(
                             "Your selected version only changes if you were playing the newest one.",
                         )),
@@ -2536,14 +2746,18 @@ impl Launcher {
                     .child(group("Launcher", "monitor"))
                     .child(index_row(
                         n + 3,
-                        "Appearance",
+                        tr("Appearance"),
                         Some(plain("Dark by default. System follows your computer's light or dark.")),
                         Some(appearance.into_any_element()),
                         &t,
                     ))
+                    .child(self.accent_row(cx))
+                    .child(self.home_background_row(cx))
+                    .child(self.language_row(cx))
+                    .child(self.while_playing_row(n + 3, cx))
                     .child(index_row(
                         n + 3,
-                        "Show the opening",
+                        tr("Show the opening"),
                         Some(plain("The wordmark, while the release list loads.")),
                         Some(opening.into_any_element()),
                         &t,
@@ -2558,24 +2772,25 @@ impl Launcher {
                     .child(index_row(n + 7, "Horizon", Some(plain(&horizon)), horizon_action, &t))
                     .child(index_row(
                         n + 8,
-                        "Launcher",
+                        tr("Launcher"),
                         Some(plain(&launcher)),
                         launcher_action,
                         &t,
                     ))
                     .child(index_row(
                         n + 9,
-                        "Data folder",
+                        tr("Data folder"),
                         Some(mono(short(&backend::data_dir()))),
                         None,
                         &t,
                     ))
                     .child(index_row(
                         n + 10,
-                        "Logs",
+                        tr("Logs"),
                         Some(mono(format!(
-                            "{}  ·  crash reports beside it",
-                            short(&backend::logs_dir())
+                            "{}  ·  {}",
+                            short(&backend::logs_dir()),
+                            tr("crash reports beside it")
                         ))),
                         Some(
                             button("open-logs", "Open", Kind::Secondary, &t)
@@ -2591,7 +2806,7 @@ impl Launcher {
                     .when(cfg!(target_os = "linux"), |d| {
                         d.child(index_row(
                             n + 11,
-                            "Applications menu",
+                            tr("Applications menu"),
                             Some(plain(if self.settings.desktop_entry() {
                                 "Horizon and its icon are in your desktop's menu."
                             } else {
@@ -2626,46 +2841,32 @@ impl Launcher {
             .font_family(theme::MONO)
             .text_size(px(12.))
             .cursor_text()
-            .child(if self.args_input.is_empty() && !focused {
-                div()
-                    .text_color(t.muted)
-                    .child("For example --server-thread")
-            } else {
-                // The end of a long line stays in view while typing.
-                let chars: Vec<char> = self.args_input.chars().collect();
-                let shown: String = chars[chars.len().saturating_sub(44)..].iter().collect();
-                div().text_color(t.ink).child(shown)
-            })
-            .when(focused, |d| d.child(div().w(px(1.)).h(px(14.)).bg(t.ink)))
+            .child(line_edit::content(
+                &self.args_input,
+                &t,
+                focused,
+                false,
+                false,
+                "For example --server-thread",
+            ))
             .on_click(cx.listener(|this, _: &ClickEvent, window, cx| {
                 window.focus(&this.args_focus);
                 cx.notify();
             }))
-            .on_key_down(cx.listener(|this, ev: &KeyDownEvent, _, cx| {
-                let k = &ev.keystroke;
-                let paste = k.key == "v" && (k.modifiers.control || k.modifiers.platform);
-                match k.key.as_str() {
-                    "backspace" => {
-                        this.args_input.pop();
+            .on_key_down(cx.listener(|this, ev: &KeyDownEvent, window, cx| {
+                match line_edit::handle(&mut this.args_input, ev, cx) {
+                    line_edit::Key::Pass => return,
+                    line_edit::Key::Escape => window.blur(),
+                    line_edit::Key::Edited => {
+                        this.settings.game_args = this.args_input.text().to_string();
+                        this.settings.save();
                     }
-                    _ if paste => {
-                        if let Some(text) = cx.read_from_clipboard().and_then(|c| c.text()) {
-                            this.args_input.push_str(text.trim());
-                        }
-                    }
-                    _ if !k.modifiers.control && !k.modifiers.platform => {
-                        if let Some(ch) = &k.key_char {
-                            this.args_input.push_str(ch);
-                        }
-                    }
-                    _ => return,
+                    _ => {}
                 }
-                this.args_input.truncate(1024);
-                this.settings.game_args = this.args_input.clone();
-                this.settings.save();
                 cx.stop_propagation();
                 cx.notify();
             }));
+        let field = line_edit::mouse(field, cx, |this| &mut this.args_input);
         index_row(
             n,
             "Game arguments",
@@ -2817,11 +3018,11 @@ impl Launcher {
                 a.name.clone(),
                 Some(
                     div()
-                        .child(if plays {
+                        .child(tr(if plays {
                             "Microsoft account · plays"
                         } else {
                             "Microsoft account · signed in"
-                        })
+                        }))
                         .into_any_element(),
                 ),
                 Some(actions.into_any_element()),
@@ -2834,8 +3035,8 @@ impl Launcher {
             Some(SignInState::Starting | SignInState::Code(_))
         );
         let detail = match &self.sign_in_state {
-            _ if !configured => div().child(account::NOT_CONFIGURED),
-            Some(SignInState::Starting) => div().child("Asking Microsoft…"),
+            _ if !configured => div().child(tr(account::NOT_CONFIGURED)),
+            Some(SignInState::Starting) => div().child(tr("Asking Microsoft…")),
             Some(SignInState::Code(code)) => div()
                 .flex()
                 .flex_col()
@@ -2855,7 +3056,7 @@ impl Launcher {
             None if self.accounts.accounts.is_empty() => div().child(
                 "Sign in to play on online servers with your name and skin. Without an account the game plays offline.",
             ),
-            None => div().child("Add another account."),
+            None => div().child(tr("Add another account.")),
         };
         let detail = if self.keychain || self.accounts.accounts.is_empty() {
             detail
@@ -2879,9 +3080,10 @@ impl Launcher {
                     .child(
                         button("sign-in-copy", "Copy code", Kind::Secondary, &t).on_click(
                             move |_, _, cx| {
-                                cx.write_to_clipboard(gpui::ClipboardItem::new_string(
-                                    user_code.clone(),
-                                ))
+                                copy_to_clipboard(
+                                    cx,
+                                    gpui::ClipboardItem::new_string(user_code.clone()),
+                                )
                             },
                         ),
                     )
@@ -2925,7 +3127,7 @@ impl Launcher {
         };
         rows = rows.child(index_row(
             n,
-            title,
+            tr(title),
             Some(detail.into_any_element()),
             action,
             &t,
@@ -2954,7 +3156,7 @@ impl Launcher {
             .text_size(px(12.))
             .cursor_text()
             .child(if self.friend_code.is_empty() && !focused {
-                div().text_color(t.muted).child("Paste an invite code")
+                div().text_color(t.muted).child(tr("Paste an invite code"))
             } else {
                 // The end of a long code stays in view while typing.
                 let shown: String = {
@@ -3003,11 +3205,11 @@ impl Launcher {
             join = disabled(join);
         }
         index_row(
-            3,
-            "Join a friend",
+            4,
+            tr("Join a friend"),
             Some(
                 div()
-                    .child("Paste the code a friend shows when they invite you.")
+                    .child(tr("Paste the code a friend shows when they invite you."))
                     .into_any_element(),
             ),
             Some(
@@ -3023,6 +3225,16 @@ impl Launcher {
         )
     }
 
+    /// Plays the selected instance straight into a world (`--world`) or a server (`--server`):
+    /// flags every Horizon release takes.
+    pub(crate) fn quick_play(&mut self, flag: &'static str, value: String) {
+        self.quick_play = Some((flag, value));
+        self.play();
+        if self.starting_client.is_none() {
+            self.quick_play = None;
+        }
+    }
+
     fn join_friend(&mut self) {
         if horizon_friends::invite::parse(&self.friend_code).is_none() {
             return;
@@ -3445,8 +3657,8 @@ impl Render for Launcher {
             window.focus(&self.root_focus);
         }
         let stone = self.art.stone(t.page_rgb, t.dark, window.scale_factor());
-        let topbar = self.topbar(cx);
-        let sidebar = self.sidebar(cx);
+        let topbar = self.topbar(window, cx);
+        let sidebar = self.sidebar(window, cx);
         let mut root = div()
             .id("root")
             .track_focus(&self.root_focus)
@@ -3462,6 +3674,10 @@ impl Render for Launcher {
                         }
                     }
                     "escape" if this.servers_escape() => {}
+                    "escape" if this.instance_escape() => {}
+                    "escape" if this.screenshot_escape() => {}
+                    "left" if this.screenshot_step(false) => {}
+                    "right" if this.screenshot_step(true) => {}
                     _ => return,
                 }
                 cx.stop_propagation();
@@ -3522,6 +3738,16 @@ impl Render for Launcher {
                 root = root.child(dialog);
             }
         }
+        root = self.import_drop_target(root, cx);
+        root = root.children(self.import_note(cx));
+        if let Some(dialog) = self.instance_dialog(cx) {
+            root = root.child(dialog);
+        }
+        if self.page == Page::Play {
+            if let Some(viewer) = self.screenshot_viewer(cx) {
+                root = root.child(viewer);
+            }
+        }
         if self.asking_consent() {
             root = root.child(self.consent_screen(cx));
         }
@@ -3586,6 +3812,7 @@ impl Render for Launcher {
             .bg(t.side)
             .children(titlebar::render(&t, window))
             .child(root.flex_1().min_h_0())
+            .children(titlebar::resize_handles(window))
     }
 }
 
@@ -3715,6 +3942,8 @@ fn main() {
                     window_bounds: Some(WindowBounds::Windowed(bounds)),
                     window_min_size: Some(size(px(960.), px(600.))),
                     titlebar: Some(titlebar::options()),
+                    #[cfg(target_os = "linux")]
+                    window_decorations: Some(gpui::WindowDecorations::Client),
                     app_id: Some("horizon-launcher".into()),
                     ..Default::default()
                 },
diff --git a/launcher/src/mcp.rs b/launcher/src/mcp.rs
index 8aff5aa13..962cd2925 100644
--- a/launcher/src/mcp.rs
+++ b/launcher/src/mcp.rs
@@ -6,6 +6,7 @@ use crate::cli_tools;
 use crate::game_tools::{self, GameTools};
 use horizon_launcher::account::{self, Accounts, SignIn, SignInState};
 use horizon_launcher::backend::{self, Job, Logged};
+use horizon_launcher::instances;
 use serde_json::{json, Value};
 use std::io::{BufRead, Write};
 use std::path::PathBuf;
@@ -24,14 +25,16 @@ struct Session {
 /// The tools the session runs itself, under their CLI names: they keep a process (the game, a
 /// server) or a sign-in going between calls. Every other CLI command is generated (cli_tools.rs).
 fn session_tools() -> Value {
-    let version = json!({ "type": "string", "description": "An installed version tag such as v2026.10.13. Default: the selected version." });
+    let version = json!({ "type": "string", "description": "An installed version tag such as v2026.10.13. Default: the selected version (play: the instance's own first)." });
     let none = json!({ "type": "object", "properties": {} });
     json!([
         { "name": "play", "description": "Start the Horizon client (a game window on the player's screen) under agent control: the game_* tools then play it. Returns once it has started; game_wait_ready waits for the world. CLI: horizon-launcher play",
           "inputSchema": { "type": "object", "properties": { "version": version,
+            "instance": { "type": "string", "description": "The instance to play, by name or id (instance_list). Default: the selected one." },
             "world": { "type": "string", "description": "Open or create this world (a folder under saves) at once." },
             "creative": { "type": "boolean", "description": "Creative mode for a new world." },
             "join": { "type": "string", "description": "Join a friend's world with its invite code. Only when the player asks." },
+            "server": { "type": "string", "description": "Join this server at once: an address, or a server of the instance's list (multiplayer_list) by name or position. Only when the player asks." },
             "offscreen": { "type": "boolean", "description": "Render without showing a window (game_screenshot still works)." },
             "arg": { "type": "array", "items": { "type": "string" }, "description": "Extra game arguments, passed through as-is (for example \"--server-thread\")." } } } },
         { "name": "server", "description": "Start a Horizon dedicated server. It runs until server_stop or the end of this MCP session. Requires agreeing to the Minecraft EULA. CLI: horizon-launcher server",
@@ -66,8 +69,13 @@ impl Session {
                 if self.client.as_ref().is_some_and(|c| c.finished().is_none()) {
                     return Err("The client is already running.".into());
                 }
-                let tag = backend::resolve_version(arg_str(args, "version"))?;
+                let instance = match arg_str(args, "instance") {
+                    Some(name) => instances::find(name)?,
+                    None => instances::selected(),
+                };
+                let tag = instance.resolve_version(arg_str(args, "version"))?;
                 let mut cmd = backend::client(&tag)?;
+                instances::apply(&mut cmd, &instance)?;
                 cmd.args(game_tools::control_args());
                 if let Some(world) = arg_str(args, "world") {
                     cmd.arg("--world").arg(world);
@@ -80,6 +88,12 @@ impl Session {
                 if let Some(code) = arg_str(args, "join") {
                     backend::join_friend(&mut cmd, code)?;
                 }
+                if let Some(server) = arg_str(args, "server") {
+                    let list = horizon_launcher::server_list::List::load(&instance.home);
+                    let ip = horizon_launcher::server_list::find(&list, server)
+                        .map_or_else(|_| server.to_string(), |(_, s)| s.ip);
+                    cmd.arg("--server").arg(ip);
+                }
                 if let Some(extra) = args.get("arg").and_then(Value::as_array) {
                     cmd.args(extra.iter().filter_map(Value::as_str));
                 }
diff --git a/launcher/src/modpacks.rs b/launcher/src/modpacks.rs
index acd8241a5..3b8e9451f 100644
--- a/launcher/src/modpacks.rs
+++ b/launcher/src/modpacks.rs
@@ -135,7 +135,11 @@ pub fn load(work: &Path) -> Result<Imported, String> {
 
 /// Every imported pack, by name.
 pub fn list() -> Vec<Imported> {
-    let mut packs: Vec<Imported> = fs::read_dir(ports_dir())
+    list_in(&ports_dir())
+}
+
+pub(crate) fn list_in(ports: &Path) -> Vec<Imported> {
+    let mut packs: Vec<Imported> = fs::read_dir(ports)
         .into_iter()
         .flatten()
         .flatten()
diff --git a/launcher/src/modpacks_page.rs b/launcher/src/modpacks_page.rs
index 25df3966f..97ce17952 100644
--- a/launcher/src/modpacks_page.rs
+++ b/launcher/src/modpacks_page.rs
@@ -25,7 +25,7 @@ impl Launcher {
     }
 
     /// Runs a pipeline step on a thread; its lines and its end arrive as messages.
-    fn pack_job(
+    pub(super) fn pack_job(
         &mut self,
         job: impl FnOnce(&dyn Fn(String)) -> Result<Imported, String> + Send + 'static,
     ) {
@@ -116,7 +116,13 @@ impl Launcher {
     }
 
     fn play_pack(&mut self, work: PathBuf) {
-        let Some(tag) = self.selected().cloned() else {
+        // The pack's instance plays its own version, if it has one.
+        let pack = self.instances.list.iter().find(|i| i.work == work);
+        let Some(tag) = pack
+            .and_then(|i| self.version_of(i))
+            .or_else(|| self.launcher_version())
+            .cloned()
+        else {
             return;
         };
         if self.client.is_some() || self.starting_client.is_some() {
@@ -132,6 +138,7 @@ impl Launcher {
             self.mods.report_list.reset();
             self.packs = modpacks::list();
             self.registry_packs = horizon_pack::list();
+            self.reload_instances();
             if self.pack_open.is_none() {
                 self.pack_open = self.packs.first().map(|p| p.slug.clone());
             }
diff --git a/launcher/src/mods_page.rs b/launcher/src/mods_page.rs
index f74fc73c1..5a3e88b24 100644
--- a/launcher/src/mods_page.rs
+++ b/launcher/src/mods_page.rs
@@ -12,13 +12,15 @@ use horizon_launcher::browser::{
 use horizon_launcher::modpacks;
 use horizon_port_pack::check::Check;
 use std::collections::HashMap;
+use std::path::PathBuf;
 
 /// The kinds, as the Mods page's tabs: name and icon.
-const KINDS: [(PackKind, &str, &str); 4] = [
+const KINDS: [(PackKind, &str, &str); 5] = [
     (PackKind::Mod, "Mods", "box"),
     (PackKind::Modpack, "Modpacks", "archive"),
     (PackKind::ResourcePack, "Resource packs", "image"),
     (PackKind::Shader, "Shader packs", "zap"),
+    (PackKind::DataPack, "Data packs", "notes"),
 ];
 /// Java mods checked at once.
 const CHECKING: usize = 2;
@@ -71,6 +73,11 @@ pub(super) struct Mods {
     error: Option<String>,
     installed: Vec<installed::Entry>,
     loaded: bool,
+    /// The game folder the browser installs into and lists: the selected instance's.
+    home: Option<PathBuf>,
+    /// Its worlds (folder, name), the last played first, and the one data packs go into.
+    worlds: Vec<(PathBuf, String)>,
+    world: Option<PathBuf>,
     /// The project being installed, and the line and fraction of its download.
     pub(super) busy: Option<(String, String, f32)>,
     message: Option<Result<String, String>>,
@@ -93,6 +100,27 @@ impl Mods {
         self.report_list.reset();
     }
 
+    /// The game folder installs go into: the selected instance's, once the page has read it.
+    pub(super) fn home(&self) -> PathBuf {
+        self.home.clone().unwrap_or_else(backend::game_home)
+    }
+
+    /// Reads the instance's worlds again; the world picked for data packs stays when it is
+    /// still there, else the last played.
+    fn read_worlds(&mut self) {
+        self.worlds = horizon_launcher::worlds::list(&self.home())
+            .into_iter()
+            .map(|w| (w.path, w.name))
+            .collect();
+        if !self
+            .worlds
+            .iter()
+            .any(|(p, _)| Some(p) == self.world.as_ref())
+        {
+            self.world = self.worlds.first().map(|(p, _)| p.clone());
+        }
+    }
+
     /// Whether the Modpacks tab is open (the sidebar marks the pack shown there).
     pub(super) fn on_modpacks(&self) -> bool {
         self.kind == PackKind::Modpack
@@ -104,6 +132,7 @@ impl Mods {
         let kind = match page.as_deref() {
             Ok("modpacks") => PackKind::Modpack,
             Ok("shaders") => PackKind::Shader,
+            Ok("datapacks") => PackKind::DataPack,
             _ => PackKind::Mod,
         };
         Self {
@@ -130,6 +159,9 @@ impl Mods {
             error: None,
             installed: Vec::new(),
             loaded: false,
+            home: None,
+            worlds: Vec::new(),
+            world: None,
             busy: None,
             message: None,
             updates: HashMap::new(),
@@ -236,6 +268,7 @@ impl Launcher {
         let mut changed = false;
         let mut to_check = Vec::new();
         let mut loaded = Vec::new();
+        let mut done = false;
         while let Ok(event) = self.mods.rx.try_recv() {
             changed = true;
             let m = &mut self.mods;
@@ -262,9 +295,10 @@ impl Launcher {
                     }
                 }
                 Event::Done(result, modpack) => {
+                    done = true;
                     m.busy = None;
                     m.message = Some(result);
-                    m.installed = installed::Installed::load(&backend::game_home()).entries;
+                    m.installed = installed::Installed::load(&m.home()).entries;
                     m.installed_list.reset();
                     if modpack {
                         // The Modpacks page reads its list again.
@@ -287,7 +321,7 @@ impl Launcher {
                 }
                 Event::TakenDown(lines) => {
                     m.message = Some(Ok(lines.join("\n")));
-                    m.installed = installed::Installed::load(&backend::game_home()).entries;
+                    m.installed = installed::Installed::load(&m.home()).entries;
                     m.installed_list.reset();
                 }
             }
@@ -309,6 +343,10 @@ impl Launcher {
             }
         }
         self.mods_check(to_check);
+        if done {
+            // A data pack put into a world shows in its list on Home.
+            self.world_packs.reread();
+        }
         for l in loaded {
             self.mods_loaded(l);
         }
@@ -363,11 +401,12 @@ impl Launcher {
             return;
         }
         let tx = self.mods.tx.clone();
+        let home = self.mods.home();
         std::thread::spawn(move || {
             let Ok(index) = horizon::index() else {
                 return;
             };
-            let lines = horizon::turn_off_revoked(&index, &backend::game_home());
+            let lines = horizon::turn_off_revoked(&index, &home);
             if !lines.is_empty() {
                 let _ = tx.send(Event::TakenDown(lines));
             }
@@ -376,7 +415,7 @@ impl Launcher {
 
     /// Turns a Horizon mod the browser installed on or off, as the game's Options > Mods does.
     fn mods_switch(&mut self, e: &installed::Entry) {
-        let home = backend::game_home();
+        let home = self.mods.home();
         let Some(id) = horizon::mod_id(e) else {
             return;
         };
@@ -418,6 +457,7 @@ impl Launcher {
         let tx = m.tx.clone();
         let queue = std::sync::Mutex::new(todo.into_iter());
         std::thread::spawn(move || {
+            // Checks are kept in the default game folder, shared by every instance.
             let home = backend::game_home();
             std::thread::scope(|s| {
                 for _ in 0..CHECKING {
@@ -468,6 +508,70 @@ impl Launcher {
         });
     }
 
+    /// Updates every installed pack a newer version was found for, one after the other on a
+    /// thread, each checked as an install is. One failing doesn't stop the others.
+    fn mods_update_all(&mut self) {
+        if self.mods.busy.is_some() || self.mods.updates.is_empty() {
+            return;
+        }
+        let mut todo: Vec<(SourceId, String, String)> = self
+            .mods
+            .installed
+            .iter()
+            .filter(|e| {
+                self.mods
+                    .updates
+                    .contains_key(&(e.source, e.project.clone()))
+            })
+            .map(|e| (e.source, e.project.clone(), e.title.clone()))
+            .collect();
+        todo.dedup_by(|a, b| a.0 == b.0 && a.1 == b.1);
+        self.mods.message = None;
+        self.mods.busy = Some(("all".into(), "Updating…".into(), 0.));
+        self.mods.updates.clear();
+        let tx = self.mods.tx.clone();
+        let home = self.mods.home();
+        std::thread::spawn(move || {
+            let count = todo.len();
+            let (mut done, mut failed) = (Vec::new(), Vec::new());
+            for (i, (source_id, id, title)) in todo.into_iter().enumerate() {
+                let step = |line: &str, f: f32| {
+                    let overall = (i as f32 + f) / count as f32;
+                    let _ = tx.send(Event::Progress(
+                        format!("{} of {count}: {line}", i + 1),
+                        overall,
+                    ));
+                };
+                let updated = browser::source(source_id)
+                    .ok_or_else(|| format!("{} isn't set up", source_id.label()))
+                    .and_then(|source| {
+                        let p = source.project(&id)?;
+                        installed::install(&*source, &p, true, &home, &step)
+                    });
+                match updated {
+                    Ok(entries) => done.extend(
+                        entries
+                            .into_iter()
+                            .filter(|e| e.project == id)
+                            .map(|e| format!("{} {}", e.title, e.number)),
+                    ),
+                    Err(e) => failed.push(format!("{title}: {e}")),
+                }
+            }
+            let updated = match done.is_empty() {
+                true => String::new(),
+                false => format!("Updated {}, checksums checked.", done.join(", ")),
+            };
+            let result = match failed.is_empty() {
+                true => Ok(updated),
+                false => Err(format!("{updated} Not updated: {}", failed.join("; "))
+                    .trim()
+                    .to_string()),
+            };
+            let _ = tx.send(Event::Done(result, false));
+        });
+    }
+
     /// Installs (or updates) a project on a thread: a pack into its folder, a modpack into
     /// Modpacks. `known` is the project when the page has it; else it is asked for first.
     pub(super) fn mods_install(&mut self, source: SourceId, id: String, known: Option<Project>) {
@@ -484,6 +588,11 @@ impl Launcher {
             .filter(|tag| backend::is_prepared(tag))
             .map(|tag| backend::resources(tag));
         let tx = self.mods.tx.clone();
+        let home = self.mods.home();
+        let world = self.mods.world.clone().and_then(|path| {
+            let (_, name) = self.mods.worlds.iter().find(|(p, _)| *p == path)?;
+            Some((path, name.clone()))
+        });
         std::thread::spawn(move || {
             let last = std::cell::Cell::new(-1);
             let progress = |line: &str, f: f32| {
@@ -500,6 +609,21 @@ impl Launcher {
                         Some(p) => p,
                         None => source.project(&id)?,
                     };
+                    if p.kind == PackKind::DataPack {
+                        let (world, name) =
+                            world.ok_or("Pick the world the data pack goes into first.")?;
+                        let done =
+                            installed::install_datapack(&*source, &p, everything, &world, &|f| {
+                                progress(&p.title, f)
+                            })?;
+                        return Ok(format!(
+                            "Put {} {} in {name}'s data packs, checksum checked: the game turns \
+                             it on when the world opens. {}",
+                            p.title,
+                            done.number,
+                            done.coverage.summary()
+                        ));
+                    }
                     modpack = p.kind == PackKind::Modpack;
                     if modpack && p.source == SourceId::Horizon {
                         let pack = horizon::pack::install(&p.id, &progress)?;
@@ -523,7 +647,6 @@ impl Launcher {
                             modpacks::outcome(&pack)
                         ));
                     }
-                    let home = backend::game_home();
                     let done = installed::install(&*source, &p, everything, &home, &progress)?;
                     let names: Vec<String> = done
                         .iter()
@@ -626,12 +749,21 @@ impl Launcher {
 
     pub(super) fn mods_page(&mut self, cx: &mut Context<Self>) -> Div {
         let t = self.theme;
-        if !self.mods.loaded {
-            self.mods.loaded = true;
-            self.mods.installed = installed::Installed::load(&backend::game_home()).entries;
+        // Packs and mods go into the selected instance: picking another reads its list.
+        let home = self.selected_instance().map(|i| i.home.clone());
+        if !self.mods.loaded || (home.is_some() && self.mods.home != home) {
+            self.mods.home = home;
+            self.mods.installed = installed::Installed::load(&self.mods.home()).entries;
+            self.mods.installed_list.reset();
+            self.mods.updates.clear();
+            self.mods.confirm_remove = None;
+            self.mods.read_worlds();
             self.mods_check_updates();
             self.mods_taken_down();
-            self.mods_search(0);
+            if !self.mods.loaded {
+                self.mods_search(0);
+            }
+            self.mods.loaded = true;
         }
         let header = page_header(
             "Mods",
@@ -652,6 +784,11 @@ impl Launcher {
                         if kind == PackKind::Shader {
                             this.mods.source = SourceId::Horizon;
                         }
+                        // Data packs are on Modrinth only; a world may have been made since.
+                        if kind == PackKind::DataPack {
+                            this.mods.source = SourceId::Modrinth;
+                            this.mods.read_worlds();
+                        }
                         // Categories and loaders differ by kind.
                         this.mods.browse.filters = Default::default();
                         this.mods.browse.open = None;
@@ -681,7 +818,8 @@ impl Launcher {
             }));
         // CurseForge support is coming soon: shown, inert, never searched (like the Microsoft
         // account's "Coming soon").
-        let source_note = div().flex().child(self.mods_source_switch(cx));
+        let source_note = (self.mods.kind != PackKind::DataPack)
+            .then(|| div().flex().child(self.mods_source_switch(cx)));
         // The registry lists only what was made for Horizon: no "everything", no Modrinth filters.
         let registry = self.mods.source == SourceId::Horizon;
         let filters = (!registry).then(|| self.mods_filters(cx));
@@ -698,8 +836,9 @@ impl Launcher {
                     .child(self.mods_field(cx))
                     .when(!registry, |d| d.child(toggle)),
             )
-            .child(source_note)
-            .children(filters);
+            .children(source_note)
+            .children(filters)
+            .children(self.mods_target_line(cx));
         // The kinds are inventory tabs on the panel that holds the open one.
         let body = blocks::panel(&t).flex().flex_col().gap(px(24.)).p(px(20.));
         let page = |body: Div| {
@@ -727,18 +866,82 @@ impl Launcher {
         page(body.child(self.mods_results(cx)))
     }
 
+    /// Which instance installs go into, when there is more than one to pick from. A modpack
+    /// becomes an instance of its own.
+    fn mods_target_line(&self, cx: &mut Context<Self>) -> Option<Div> {
+        let instance = self.selected_instance()?;
+        if self.mods.kind == PackKind::DataPack {
+            return Some(self.mods_world_picker(&instance.name.clone(), cx));
+        }
+        if self.instances.list.len() < 2 || self.mods.kind == PackKind::Modpack {
+            return None;
+        }
+        Some(
+            text(theme::CAPTION)
+                .text_color(self.theme.muted)
+                .child(format!(
+                    "Installs into {}: pick another instance on the left.",
+                    instance.name
+                )),
+        )
+    }
+
+    /// The world data packs go into: one of the instance's, picked here.
+    fn mods_world_picker(&self, instance: &str, cx: &mut Context<Self>) -> Div {
+        let t = self.theme;
+        let caption = |s: String| text(theme::CAPTION).text_color(t.muted).child(s);
+        if self.mods.worlds.is_empty() {
+            return div().child(caption(format!(
+                "A data pack goes into a world, and {instance} has none yet: create one in the \
+                 game, then come back."
+            )));
+        }
+        let mut chips = div().flex().flex_wrap().items_center().gap(px(6.));
+        for (i, (path, name)) in self.mods.worlds.iter().enumerate() {
+            let on = self.mods.world.as_ref() == Some(path);
+            let path = path.clone();
+            chips = chips.child(
+                button(
+                    SharedString::from(format!("mods-world-{i}")),
+                    name.clone(),
+                    if on { Kind::Secondary } else { Kind::Ghost },
+                    &t,
+                )
+                .when(on, |b| b.border_color(t.accent))
+                .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                    this.mods.world = Some(path.clone());
+                    cx.notify();
+                })),
+            );
+        }
+        div()
+            .flex()
+            .flex_col()
+            .gap(px(8.))
+            .child(caption(format!(
+                "Installs into a world of {instance}; the game turns the pack on when the world \
+                 opens."
+            )))
+            .child(chips)
+    }
+
     /// The install under way and the last install's answer.
     pub(super) fn mods_busy_plate(&self) -> Vec<Div> {
         let t = self.theme;
         let mut out = Vec::new();
-        if let Some((_, line, f)) = &self.mods.busy {
+        if let Some((what, line, f)) = &self.mods.busy {
+            let caption = if what == "all" {
+                "Updating"
+            } else {
+                "Installing"
+            };
             out.push(
                 plate(&t)
                     .flex()
                     .flex_col()
                     .gap(px(8.))
                     .p(px(16.))
-                    .child(caps("Installing").text_color(t.accent))
+                    .child(caps(caption).text_color(t.accent))
                     .child(
                         text(theme::CAPTION)
                             .font_family(theme::MONO)
@@ -816,7 +1019,7 @@ impl Launcher {
             .when(confirming, |b| b.text_color(t.danger))
             .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
                 if this.mods.confirm_remove.as_ref() == Some(&id) {
-                    let home = backend::game_home();
+                    let home = this.mods.home();
                     this.mods.message = Some(
                         installed::remove(&home, &id).map(|e| format!("Removed {}.", e.title)),
                     );
@@ -829,8 +1032,8 @@ impl Launcher {
                 cx.notify();
             }));
             if e.source == SourceId::Horizon && e.kind == PackKind::Mod {
-                let on = horizon::mod_id(e)
-                    .is_some_and(|id| java::is_enabled(&backend::game_home(), id));
+                let on =
+                    horizon::mod_id(e).is_some_and(|id| java::is_enabled(&self.mods.home(), id));
                 let entry = e.clone();
                 right = right.child(
                     div()
@@ -889,6 +1092,23 @@ impl Launcher {
                 &t,
             )
         };
+        // Every kind's updates at once, whichever tab is open.
+        let update_all = (!self.mods.updates.is_empty()).then(|| {
+            let b = button(
+                "mods-update-all",
+                format!("Update all ({})", self.mods.updates.len()),
+                Kind::Secondary,
+                &t,
+            );
+            if busy {
+                disabled(b)
+            } else {
+                b.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                    this.mods_update_all();
+                    cx.notify();
+                }))
+            }
+        });
         let list = self.mods.installed_list.column(
             &self.content_scroll.handle,
             entries.len(),
@@ -901,7 +1121,14 @@ impl Launcher {
                 .flex()
                 .flex_col()
                 .gap(px(12.))
-                .child(caps("Installed").text_color(t.muted))
+                .child(
+                    div()
+                        .flex()
+                        .items_center()
+                        .justify_between()
+                        .child(caps("Installed").text_color(t.muted))
+                        .children(update_all),
+                )
                 .child(list),
         )
     }
diff --git a/launcher/src/multiplayer_page.rs b/launcher/src/multiplayer_page.rs
new file mode 100644
index 000000000..867a08ce9
--- /dev/null
+++ b/launcher/src/multiplayer_page.rs
@@ -0,0 +1,251 @@
+//! The selected instance's server list on Home (`horizon_launcher::server_list`, the game's own
+//! `servers.dat`): each server with the picture the game last saw, Join (the game starts straight
+//! into it), Remove after a confirmation, and a line to add one.
+use super::*;
+use gpui::{Image, ImageFormat};
+use horizon_launcher::server_list::{self, Server};
+use servers_page::Field;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+#[derive(Default)]
+pub(super) struct Multiplayer {
+    /// The game folder the list is of, and the list as last read with each picture decoded.
+    home: Option<PathBuf>,
+    list: Vec<(Server, Option<Arc<Image>>)>,
+    fresh: bool,
+    adding: bool,
+    confirm_remove: Option<usize>,
+    error: Option<String>,
+}
+
+impl Multiplayer {
+    /// Read again on the next frame: the game may have changed its list.
+    pub(super) fn stale(&mut self) {
+        self.fresh = false;
+    }
+}
+
+impl Launcher {
+    fn load_servers(&mut self, home: PathBuf) {
+        if self.multiplayer.home.as_ref() != Some(&home) {
+            self.multiplayer = Multiplayer {
+                home: Some(home.clone()),
+                ..Multiplayer::default()
+            };
+        }
+        if self.multiplayer.fresh {
+            return;
+        }
+        // A few servers and their 64×64 pictures: small enough to read while drawing.
+        self.multiplayer.list = server_list::List::load(&home)
+            .servers()
+            .into_iter()
+            .map(|s| {
+                let icon = s
+                    .icon
+                    .clone()
+                    .map(|png| Arc::new(Image::from_bytes(ImageFormat::Png, png)));
+                (s, icon)
+            })
+            .collect();
+        self.multiplayer.fresh = true;
+    }
+
+    fn edit_servers(&mut self, edit: impl FnOnce(&mut server_list::List) -> Result<(), String>) {
+        let Some(home) = self.multiplayer.home.clone() else {
+            return;
+        };
+        let mut list = server_list::List::load(&home);
+        self.multiplayer.error = edit(&mut list).and_then(|()| list.save(&home)).err();
+        self.multiplayer.confirm_remove = None;
+        self.multiplayer.stale();
+    }
+
+    /// Enter in the address field, or Add.
+    pub(super) fn add_server(&mut self) {
+        let name = self.servers.value(Field::ServerName).to_string();
+        let address = self.servers.value(Field::ServerAddress).to_string();
+        self.edit_servers(|list| list.add(&name, &address));
+        if self.multiplayer.error.is_none() {
+            self.servers.text(Field::ServerName).clear();
+            self.servers.text(Field::ServerAddress).clear();
+            self.multiplayer.adding = false;
+        }
+    }
+
+    /// Home's Multiplayer section, for the selected instance.
+    pub(super) fn multiplayer_section(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let home = self.selected_instance()?.home.clone();
+        self.load_servers(home);
+        let header = div()
+            .flex()
+            .items_center()
+            .justify_between()
+            .mb(px(4.))
+            .child(section_title("Multiplayer", "server", &t))
+            .child(
+                button("server-add", "Add server", Kind::Ghost, &t).on_click(cx.listener(
+                    |this, _: &ClickEvent, _, cx| {
+                        this.multiplayer.adding = !this.multiplayer.adding;
+                        this.multiplayer.error = None;
+                        if this.multiplayer.adding {
+                            this.servers.focus_soon = Some(Field::ServerAddress);
+                        }
+                        cx.notify();
+                    },
+                )),
+            );
+        let mut section = div().flex().flex_col().gap(px(8.)).child(header);
+        if let Some(e) = self.multiplayer.error.clone() {
+            section = section.child(notice(e, &t));
+        }
+        if self.multiplayer.adding {
+            section = section.child(
+                plate(&t)
+                    .flex()
+                    .items_center()
+                    .gap(px(8.))
+                    .px(px(14.))
+                    .py(px(10.))
+                    .child(self.field(Field::ServerName, "Minecraft Server", 220., cx))
+                    .child(self.field(Field::ServerAddress, "play.example.com", 300., cx))
+                    .child(button("server-save", "Add", Kind::Secondary, &t).on_click(
+                        cx.listener(|this, _: &ClickEvent, _, cx| {
+                            this.add_server();
+                            cx.notify();
+                        }),
+                    )),
+            );
+        }
+        let list = self.multiplayer.list.clone();
+        if list.is_empty() && !self.multiplayer.adding {
+            section = section.child(
+                text(theme::CAPTION)
+                    .text_color(t.muted)
+                    .child("No servers yet: add one here or in the game's Multiplayer screen."),
+            );
+        }
+        for (i, (server, icon)) in list.into_iter().enumerate() {
+            section = section.child(self.server_row(i, server, icon, cx));
+        }
+        Some(section)
+    }
+
+    fn server_row(
+        &mut self,
+        i: usize,
+        server: Server,
+        icon: Option<Arc<Image>>,
+        cx: &mut Context<Self>,
+    ) -> Div {
+        let t = self.theme;
+        let picture = div()
+            .flex()
+            .flex_none()
+            .items_center()
+            .justify_center()
+            .size(px(48.))
+            .border_2()
+            .border_color(t.outline)
+            .bg(t.well);
+        let picture = match icon {
+            Some(image) => picture.child(gpui::img(image).size(px(44.))),
+            None => picture.child(blocks::icon("server", 22., t.muted)),
+        };
+        let mut actions = div().flex().items_center().gap(px(6.));
+        if self.multiplayer.confirm_remove == Some(i) {
+            actions = actions
+                .child(
+                    text(theme::CAPTION)
+                        .text_color(t.danger)
+                        .child("Remove it from the list?"),
+                )
+                .child(
+                    button(
+                        SharedString::from(format!("server-keep-{i}")),
+                        "Keep",
+                        Kind::Ghost,
+                        &t,
+                    )
+                    .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                        this.multiplayer.confirm_remove = None;
+                        cx.notify();
+                    })),
+                )
+                .child(
+                    button(
+                        SharedString::from(format!("server-remove-{i}")),
+                        "Remove",
+                        Kind::Secondary,
+                        &t,
+                    )
+                    .on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            this.edit_servers(|list| list.remove(i).map(|_| ()));
+                            cx.notify();
+                        },
+                    )),
+                );
+        } else {
+            let ip = server.ip.clone();
+            let busy = self.client.is_some() || self.starting_client.is_some();
+            let join = button(
+                SharedString::from(format!("server-join-{i}")),
+                "Join",
+                Kind::Secondary,
+                &t,
+            );
+            let join = if busy { disabled(join) } else { join };
+            actions = actions
+                .child(
+                    join.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        this.quick_play("--server", ip.clone());
+                        cx.notify();
+                    })),
+                )
+                .child(
+                    button(
+                        SharedString::from(format!("server-delete-{i}")),
+                        "Remove",
+                        Kind::Ghost,
+                        &t,
+                    )
+                    .on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            this.multiplayer.confirm_remove = Some(i);
+                            cx.notify();
+                        },
+                    )),
+                );
+        }
+        plate(&t)
+            .flex()
+            .items_center()
+            .gap(px(14.))
+            .px(px(14.))
+            .py(px(10.))
+            .child(picture)
+            .child(
+                div()
+                    .flex()
+                    .flex_col()
+                    .flex_1()
+                    .min_w_0()
+                    .child(
+                        blocks::pixel(15., FontWeight::MEDIUM)
+                            .text_color(t.ink)
+                            .truncate()
+                            .child(server.name.clone()),
+                    )
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.muted)
+                            .truncate()
+                            .child(server.ip.clone()),
+                    ),
+            )
+            .child(actions)
+    }
+}
diff --git a/launcher/src/packs.rs b/launcher/src/packs.rs
new file mode 100644
index 000000000..7845fdcde
--- /dev/null
+++ b/launcher/src/packs.rs
@@ -0,0 +1,338 @@
+//! An instance's resource packs and shader packs, as the game finds and picks them.
+//!
+//! - Resource packs: `resourcepacks/` in the game folder, each a `.zip` or a folder with a
+//!   `pack.mcmeta`. The ones turned on are `options.txt`'s `resourcePacks` list (vanilla's
+//!   format, `"file/<name>"`, the bottom first), so the game's Resource Packs screen shows the
+//!   same choice. A pack turned on here goes on top, as the screen puts a newly picked one.
+//! - Shader packs: `shaderpacks/`, Horizon's own (a folder with `horizon-shaders.toml`, or a
+//!   `.hshader`) and those in the `shaders/` format (a `.zip`, or a folder with `shaders/`), as
+//!   the game's Shader Packs page lists them (`shader_pack_list`). One at most is on:
+//!   `pickedShaderPack` in `horizon-graphics.txt`.
+//!
+//! Every other line of both files is written back as it was.
+use std::fs;
+use std::io::Read;
+use std::path::{Path, PathBuf};
+
+const OPTIONS: &str = "options.txt";
+const GRAPHICS: &str = "horizon-graphics.txt";
+const SHADER_MANIFEST: &str = "horizon-shaders.toml";
+const SHADER_PACKAGE: &str = "hshader";
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Kind {
+    Resource,
+    Shader,
+}
+
+impl Kind {
+    pub fn folder(self) -> &'static str {
+        match self {
+            Kind::Resource => "resourcepacks",
+            Kind::Shader => "shaderpacks",
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Pack {
+    pub kind: Kind,
+    /// Its file or folder name in the pack folder: the id commands take.
+    pub file: String,
+    pub path: PathBuf,
+    /// A Horizon shader pack's own name, else the file's.
+    pub title: String,
+    /// `pack.mcmeta`'s description as plain text; a shader pack's format.
+    pub description: String,
+    /// `pack.png`, a resource pack's picture.
+    pub icon: Option<Vec<u8>>,
+    pub enabled: bool,
+}
+
+/// The packs of `kind` in the game folder `home`, by name: turning one on or off leaves it where
+/// it is.
+pub fn list(home: &Path, kind: Kind) -> Vec<Pack> {
+    let on = enabled(home, kind);
+    let mut packs: Vec<Pack> = fs::read_dir(home.join(kind.folder()))
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter_map(|e| read(&e.path(), kind, &on))
+        .collect();
+    packs.sort_by_key(|p| p.title.to_lowercase());
+    packs
+}
+
+/// The file names turned on, bottom first.
+fn enabled(home: &Path, kind: Kind) -> Vec<String> {
+    match kind {
+        Kind::Resource => option_list(&fs::read_to_string(home.join(OPTIONS)).unwrap_or_default())
+            .into_iter()
+            .filter_map(|id| id.strip_prefix("file/").map(str::to_string))
+            .collect(),
+        Kind::Shader => line_value(
+            &fs::read_to_string(home.join(GRAPHICS)).unwrap_or_default(),
+            "pickedShaderPack",
+        )
+        .filter(|v| !v.is_empty())
+        .into_iter()
+        .collect(),
+    }
+}
+
+fn read(path: &Path, kind: Kind, on: &[String]) -> Option<Pack> {
+    let file = path.file_name()?.to_str()?.to_string();
+    if file.starts_with('.') {
+        return None;
+    }
+    let ext =
+        |x: &str| path.is_file() && path.extension().is_some_and(|e| e.eq_ignore_ascii_case(x));
+    let (title, description, icon) = match kind {
+        Kind::Resource => {
+            let meta = entry(path, "pack.mcmeta")?;
+            let meta: serde_json::Value = serde_json::from_slice(&meta).ok()?;
+            (
+                file.clone(),
+                plain(&meta["pack"]["description"]),
+                entry(path, "pack.png"),
+            )
+        }
+        Kind::Shader if path.join(SHADER_MANIFEST).is_file() || ext(SHADER_PACKAGE) => {
+            let name = entry(path, SHADER_MANIFEST)
+                .and_then(|t| toml::from_slice::<toml::Table>(&t).ok())
+                .and_then(|t| t.get("name")?.as_str().map(str::to_string));
+            (
+                name.unwrap_or_else(|| file.clone()),
+                "Horizon shader pack".into(),
+                None,
+            )
+        }
+        Kind::Shader if ext("zip") || path.join("shaders").is_dir() => {
+            (file.clone(), "shaders/ format".into(), None)
+        }
+        Kind::Shader => return None,
+    };
+    Some(Pack {
+        kind,
+        enabled: on.contains(&file),
+        path: path.to_path_buf(),
+        file,
+        title,
+        description,
+        icon,
+    })
+}
+
+/// A file at the root of a pack folder or zip, at most 4 MB.
+pub(crate) fn entry(path: &Path, name: &str) -> Option<Vec<u8>> {
+    let mut out = Vec::new();
+    if path.is_dir() {
+        fs::File::open(path.join(name))
+            .ok()?
+            .take(4 << 20)
+            .read_to_end(&mut out)
+            .ok()?;
+    } else {
+        let mut zip = zip::ZipArchive::new(fs::File::open(path).ok()?).ok()?;
+        let entry = zip.by_name(name).ok()?;
+        entry.take(4 << 20).read_to_end(&mut out).ok()?;
+    }
+    Some(out)
+}
+
+/// A text component as plain text: its strings, without `§` formatting codes.
+pub(crate) fn plain(component: &serde_json::Value) -> String {
+    fn walk(v: &serde_json::Value, out: &mut String) {
+        match v {
+            serde_json::Value::String(s) => out.push_str(s),
+            serde_json::Value::Array(a) => a.iter().for_each(|v| walk(v, out)),
+            serde_json::Value::Object(o) => {
+                if let Some(t) = o.get("text").or_else(|| o.get("translate")) {
+                    walk(t, out);
+                }
+                if let Some(extra) = o.get("extra") {
+                    walk(extra, out);
+                }
+            }
+            _ => {}
+        }
+    }
+    let mut raw = String::new();
+    walk(component, &mut raw);
+    let mut out = String::new();
+    let mut chars = raw.chars();
+    while let Some(c) = chars.next() {
+        match c {
+            '§' => {
+                chars.next();
+            }
+            '\n' => out.push(' '),
+            c => out.push(c),
+        }
+    }
+    out.trim().to_string()
+}
+
+/// `key:value` in a `key:value` per line file.
+fn line_value(text: &str, key: &str) -> Option<String> {
+    text.lines()
+        .find_map(|l| l.strip_prefix(key)?.strip_prefix(':'))
+        .map(str::to_string)
+}
+
+/// `resourcePacks:["vanilla","file/x.zip"]` in options.txt.
+fn option_list(options: &str) -> Vec<String> {
+    line_value(options, "resourcePacks")
+        .and_then(|v| serde_json::from_str(&v).ok())
+        .unwrap_or_default()
+}
+
+/// Sets `key:value` in the file, or adds the line; every other line stays.
+fn set_line(path: &Path, key: &str, value: &str) -> Result<(), String> {
+    let text = fs::read_to_string(path).unwrap_or_default();
+    let mut found = false;
+    let mut out: Vec<String> = text
+        .lines()
+        .map(
+            |l| match l.strip_prefix(key).and_then(|r| r.strip_prefix(':')) {
+                Some(_) if !found => {
+                    found = true;
+                    format!("{key}:{value}")
+                }
+                _ => l.to_string(),
+            },
+        )
+        .collect();
+    if !found {
+        out.push(format!("{key}:{value}"));
+    }
+    let mut text = out.join("\n");
+    text.push('\n');
+    if let Some(dir) = path.parent() {
+        fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    }
+    fs::write(path, text).map_err(|e| format!("{}: {e}", path.display()))
+}
+
+/// Turns a pack on or off. A resource pack turned on goes on top; a shader pack turned on
+/// replaces the one that was.
+pub fn set_enabled(home: &Path, pack: &Pack, on: bool) -> Result<(), String> {
+    match pack.kind {
+        Kind::Resource => {
+            let options = home.join(OPTIONS);
+            let text = fs::read_to_string(&options).unwrap_or_default();
+            let id = format!("file/{}", pack.file);
+            let mut list = option_list(&text);
+            list.retain(|i| *i != id);
+            if list.is_empty() {
+                list.push("vanilla".into());
+            }
+            if on {
+                list.push(id.clone());
+            } else {
+                // The game's "use it anyway" answer goes with it.
+                let mut incompatible: Vec<String> = line_value(&text, "incompatibleResourcePacks")
+                    .and_then(|v| serde_json::from_str(&v).ok())
+                    .unwrap_or_default();
+                if incompatible.contains(&id) {
+                    incompatible.retain(|i| *i != id);
+                    let value = serde_json::to_string(&incompatible).unwrap();
+                    set_line(&options, "incompatibleResourcePacks", &value)?;
+                }
+            }
+            set_line(
+                &options,
+                "resourcePacks",
+                &serde_json::to_string(&list).unwrap(),
+            )
+        }
+        Kind::Shader => {
+            let value = if on { pack.file.as_str() } else { "" };
+            set_line(&home.join(GRAPHICS), "pickedShaderPack", value)
+        }
+    }
+}
+
+/// The pack a command names: its file name, or its title (any case).
+pub fn find(home: &Path, kind: Kind, query: &str) -> Result<Pack, String> {
+    let all = list(home, kind);
+    all.iter()
+        .find(|p| p.file == query)
+        .or_else(|| all.iter().find(|p| p.title.eq_ignore_ascii_case(query)))
+        .cloned()
+        .ok_or_else(|| format!("No pack {query} in {}", home.join(kind.folder()).display()))
+}
+
+/// What a dropped or picked file is: a resource pack (a zip with `pack.mcmeta`), a Horizon
+/// shader pack (`.hshader`), or a shader pack in the `shaders/` format (a zip with `shaders/`).
+pub fn kind_of(file: &Path) -> Result<Kind, String> {
+    let name = file
+        .file_name()
+        .map(|n| n.to_string_lossy().into_owned())
+        .unwrap_or_default();
+    let ext = file
+        .extension()
+        .map(|e| e.to_string_lossy().to_ascii_lowercase());
+    match ext.as_deref() {
+        Some(SHADER_PACKAGE) => return Ok(Kind::Shader),
+        Some("zip") => {}
+        _ => {
+            return Err(format!(
+                "{name} is not a pack: packs are .zip or .hshader files."
+            ))
+        }
+    }
+    let zip = fs::File::open(file)
+        .ok()
+        .and_then(|f| zip::ZipArchive::new(f).ok())
+        .ok_or_else(|| format!("{name} is not a zip file that can be read."))?;
+    if zip.index_for_name("pack.mcmeta").is_some() {
+        Ok(Kind::Resource)
+    } else if zip.file_names().any(|n| n.starts_with("shaders/")) {
+        Ok(Kind::Shader)
+    } else {
+        Err(format!(
+            "{name} has neither a pack.mcmeta (a resource pack) nor a shaders folder (a shader pack)."
+        ))
+    }
+}
+
+/// Copies a pack file into the right folder of `home`, under a name not taken yet. Returns it,
+/// turned off.
+pub fn add(home: &Path, file: &Path) -> Result<Pack, String> {
+    let kind = kind_of(file)?;
+    let dir = home.join(kind.folder());
+    fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let name = file.file_name().ok_or("A pack file has a name")?;
+    let stem = Path::new(name)
+        .file_stem()
+        .unwrap_or(name)
+        .to_string_lossy();
+    let ext = Path::new(name)
+        .extension()
+        .map(|e| format!(".{}", e.to_string_lossy()))
+        .unwrap_or_default();
+    let target = (1..)
+        .map(|n| match n {
+            1 => dir.join(name),
+            n => dir.join(format!("{stem} ({n}){ext}")),
+        })
+        .find(|p| !p.exists())
+        .unwrap();
+    fs::copy(file, &target).map_err(|e| format!("Could not copy {}: {e}", file.display()))?;
+    read(&target, kind, &[])
+        .ok_or_else(|| format!("{} is not a pack the game reads", target.display()))
+}
+
+/// Turns the pack off and moves it to the system's trash.
+pub fn remove(home: &Path, pack: &Pack) -> Result<(), String> {
+    if pack.enabled {
+        set_enabled(home, pack, false)?;
+    }
+    crate::desktop_seams::to_trash(&pack.path)
+        .map_err(|e| format!("Could not move {} to the trash: {e}", pack.file))
+}
+
+#[cfg(test)]
+#[path = "packs/tests.rs"]
+mod tests;
diff --git a/launcher/src/packs/tests.rs b/launcher/src/packs/tests.rs
new file mode 100644
index 000000000..05a2c6b94
--- /dev/null
+++ b/launcher/src/packs/tests.rs
@@ -0,0 +1,174 @@
+use super::*;
+use std::io::Write;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-packs-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+fn zip_file(path: &Path, files: &[(&str, &[u8])]) {
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    let mut zip = zip::ZipWriter::new(fs::File::create(path).unwrap());
+    for (name, bytes) in files {
+        zip.start_file(*name, zip::write::SimpleFileOptions::default())
+            .unwrap();
+        zip.write_all(bytes).unwrap();
+    }
+    zip.finish().unwrap();
+}
+
+const META: &[u8] = "{\"pack\":{\"pack_format\":69,\"description\":[\"\",{\"text\":\"Smooth \u{a7}aglass\"},\"\\nand more\"]}}"
+    .as_bytes();
+
+/// A game folder with three resource packs (one on), and shader packs of both kinds.
+fn home(name: &str) -> PathBuf {
+    let home = scratch(name);
+    let rp = home.join("resourcepacks");
+    zip_file(
+        &rp.join("Glass.zip"),
+        &[("pack.mcmeta", META), ("pack.png", b"png")],
+    );
+    zip_file(&rp.join("Broken.zip"), &[("readme.txt", b"no meta")]);
+    fs::create_dir_all(rp.join("Folder Pack")).unwrap();
+    fs::write(
+        rp.join("Folder Pack/pack.mcmeta"),
+        br#"{"pack":{"description":"Mine"}}"#,
+    )
+    .unwrap();
+    zip_file(&rp.join("Zed.zip"), &[("pack.mcmeta", META)]);
+    let sp = home.join("shaderpacks");
+    fs::create_dir_all(sp.join("warm")).unwrap();
+    fs::write(
+        sp.join("warm/horizon-shaders.toml"),
+        "schema = 1\nid = \"warm\"\nname = \"Warm Light\"\n",
+    )
+    .unwrap();
+    zip_file(&sp.join("Classic.zip"), &[("shaders/final.fsh", b"")]);
+    fs::write(sp.join("notes.txt"), b"").unwrap();
+    fs::write(
+        home.join("options.txt"),
+        "version:4786\nresourcePacks:[\"vanilla\",\"file/Zed.zip\"]\nincompatibleResourcePacks:[\"file/Zed.zip\"]\nlang:fr_ch\n",
+    )
+    .unwrap();
+    fs::write(
+        home.join("horizon-graphics.txt"),
+        "preset:custom\npickedShaderPack:\nfxaa:true\n",
+    )
+    .unwrap();
+    home
+}
+
+#[test]
+fn lists_what_the_game_reads_and_which_are_on() {
+    let home = home("list");
+    let rp = list(&home, Kind::Resource);
+    let names: Vec<(&str, bool)> = rp.iter().map(|p| (p.file.as_str(), p.enabled)).collect();
+    assert_eq!(
+        names,
+        [
+            ("Folder Pack", false),
+            ("Glass.zip", false),
+            ("Zed.zip", true)
+        ],
+        "by name; the pack without pack.mcmeta is left out, as the game does"
+    );
+    let glass = &rp[1];
+    assert_eq!(glass.description, "Smooth glass and more");
+    assert_eq!(glass.icon.as_deref(), Some(&b"png"[..]));
+    let sp = list(&home, Kind::Shader);
+    let names: Vec<&str> = sp.iter().map(|p| p.title.as_str()).collect();
+    assert_eq!(names, ["Classic.zip", "Warm Light"]);
+    assert!(list(&home.join("none"), Kind::Shader).is_empty());
+    fs::remove_dir_all(&home).unwrap();
+}
+
+#[test]
+fn turning_packs_on_and_off_writes_the_games_own_lines() {
+    let home = home("toggle");
+    let glass = find(&home, Kind::Resource, "Glass.zip").unwrap();
+    set_enabled(&home, &glass, true).unwrap();
+    let folder = find(&home, Kind::Resource, "folder pack").unwrap();
+    set_enabled(&home, &folder, true).unwrap();
+    assert!(
+        fs::read_to_string(home.join("options.txt")).unwrap().contains(
+            "resourcePacks:[\"vanilla\",\"file/Zed.zip\",\"file/Glass.zip\",\"file/Folder Pack\"]\n"
+        ),
+        "the newest on top"
+    );
+    let zed = find(&home, Kind::Resource, "Zed.zip").unwrap();
+    set_enabled(&home, &zed, false).unwrap();
+    assert_eq!(
+        fs::read_to_string(home.join("options.txt")).unwrap(),
+        "version:4786\nresourcePacks:[\"vanilla\",\"file/Glass.zip\",\"file/Folder Pack\"]\nincompatibleResourcePacks:[]\nlang:fr_ch\n"
+    );
+
+    let warm = find(&home, Kind::Shader, "Warm Light").unwrap();
+    set_enabled(&home, &warm, true).unwrap();
+    let classic = find(&home, Kind::Shader, "Classic.zip").unwrap();
+    set_enabled(&home, &classic, true).unwrap();
+    assert_eq!(
+        fs::read_to_string(home.join("horizon-graphics.txt")).unwrap(),
+        "preset:custom\npickedShaderPack:Classic.zip\nfxaa:true\n",
+        "one shader pack at a time"
+    );
+    set_enabled(
+        &home,
+        &find(&home, Kind::Shader, "Classic.zip").unwrap(),
+        false,
+    )
+    .unwrap();
+    assert!(list(&home, Kind::Shader).iter().all(|p| !p.enabled));
+
+    // A fresh instance has neither file yet.
+    let fresh = scratch("fresh");
+    fs::create_dir_all(fresh.join("resourcepacks")).unwrap();
+    fs::copy(
+        home.join("resourcepacks/Zed.zip"),
+        fresh.join("resourcepacks/Zed.zip"),
+    )
+    .unwrap();
+    set_enabled(
+        &fresh,
+        &find(&fresh, Kind::Resource, "Zed.zip").unwrap(),
+        true,
+    )
+    .unwrap();
+    assert_eq!(
+        fs::read_to_string(fresh.join("options.txt")).unwrap(),
+        "resourcePacks:[\"vanilla\",\"file/Zed.zip\"]\n"
+    );
+    fs::remove_dir_all(&home).unwrap();
+    fs::remove_dir_all(&fresh).unwrap();
+}
+
+#[test]
+fn a_dropped_file_goes_to_its_folder_under_a_free_name() {
+    let home = home("add");
+    let drops = scratch("drops");
+    zip_file(&drops.join("Zed.zip"), &[("pack.mcmeta", META)]);
+    zip_file(&drops.join("Shiny.zip"), &[("shaders/composite.fsh", b"")]);
+    fs::write(drops.join("glow.hshader"), b"PK").unwrap();
+    zip_file(&drops.join("random.zip"), &[("a.txt", b"")]);
+    fs::write(drops.join("picture.png"), b"").unwrap();
+
+    let added = add(&home, &drops.join("Zed.zip")).unwrap();
+    assert_eq!(
+        (added.kind, added.file.as_str(), added.enabled),
+        (Kind::Resource, "Zed (2).zip", false)
+    );
+    assert_eq!(
+        add(&home, &drops.join("Shiny.zip")).unwrap().kind,
+        Kind::Shader
+    );
+    assert!(home.join("shaderpacks/Shiny.zip").is_file());
+    assert_eq!(kind_of(&drops.join("glow.hshader")).unwrap(), Kind::Shader);
+    assert!(add(&home, &drops.join("random.zip")).is_err());
+    assert!(add(&home, &drops.join("picture.png")).is_err());
+    fs::remove_dir_all(&home).unwrap();
+    fs::remove_dir_all(&drops).unwrap();
+}
diff --git a/launcher/src/packs_page.rs b/launcher/src/packs_page.rs
new file mode 100644
index 000000000..d33b257dd
--- /dev/null
+++ b/launcher/src/packs_page.rs
@@ -0,0 +1,308 @@
+//! The selected instance's resource packs and shader packs on Home (`horizon_launcher::packs`):
+//! each turned on or off with one click, Remove (to the trash, after a confirmation), and
+//! Add (a file picker) or a .zip or .hshader dropped anywhere on the section.
+use super::*;
+use gpui::{ExternalPaths, Image, ImageFormat};
+use horizon_launcher::packs::{self, Kind as PackKind, Pack};
+use std::path::PathBuf;
+use std::sync::Arc;
+
+#[derive(Default)]
+pub(super) struct Packs {
+    home: Option<PathBuf>,
+    resource: Vec<(Pack, Option<Arc<Image>>)>,
+    shader: Vec<Pack>,
+    fresh: bool,
+    /// The pack waiting for its removal to be confirmed: its kind and file.
+    confirm_remove: Option<(PackKind, String)>,
+    /// What the last action did, or why it failed.
+    note: Option<Result<String, String>>,
+}
+
+impl Packs {
+    pub(super) fn stale(&mut self) {
+        self.fresh = false;
+    }
+}
+
+impl Launcher {
+    fn load_packs_list(&mut self, home: PathBuf) {
+        if self.game_packs.home.as_ref() != Some(&home) {
+            self.game_packs = Packs {
+                home: Some(home.clone()),
+                ..Packs::default()
+            };
+        }
+        if self.game_packs.fresh {
+            return;
+        }
+        // A few small reads per pack (pack.mcmeta, pack.png): fine while drawing.
+        self.game_packs.resource = packs::list(&home, PackKind::Resource)
+            .into_iter()
+            .map(|p| {
+                let icon = p
+                    .icon
+                    .clone()
+                    .map(|png| Arc::new(Image::from_bytes(ImageFormat::Png, png)));
+                (p, icon)
+            })
+            .collect();
+        self.game_packs.shader = packs::list(&home, PackKind::Shader);
+        self.game_packs.fresh = true;
+    }
+
+    fn pack_action(&mut self, act: impl FnOnce(&std::path::Path) -> Result<String, String>) {
+        let Some(home) = self.game_packs.home.clone() else {
+            return;
+        };
+        self.game_packs.note = Some(act(&home));
+        self.game_packs.confirm_remove = None;
+        self.game_packs.stale();
+    }
+
+    /// Copies dropped or picked files into the instance's pack folders.
+    fn add_packs(&mut self, files: Vec<PathBuf>) {
+        self.pack_action(|home| {
+            let mut added = Vec::new();
+            for file in &files {
+                added.push(packs::add(home, file)?.title);
+            }
+            Ok(format!("Added {}: turn it on below.", added.join(", ")))
+        });
+    }
+
+    fn choose_packs(&mut self, cx: &mut Context<Self>) {
+        let paths = cx.prompt_for_paths(PathPromptOptions {
+            files: true,
+            directories: false,
+            multiple: true,
+            prompt: Some("Add".into()),
+        });
+        cx.spawn(async move |this, cx| {
+            if let Ok(Ok(Some(paths))) = paths.await {
+                let _ = this.update(cx, |this, cx| {
+                    this.add_packs(paths);
+                    cx.notify();
+                });
+            }
+        })
+        .detach();
+    }
+
+    /// Home's Packs section, for the selected instance.
+    pub(super) fn packs_section(&mut self, cx: &mut Context<Self>) -> Option<Stateful<Div>> {
+        let t = self.theme;
+        let home = self.selected_instance()?.home.clone();
+        self.load_packs_list(home.clone());
+        let header =
+            div()
+                .flex()
+                .items_center()
+                .justify_between()
+                .mb(px(4.))
+                .child(section_title("Packs", "package", &t))
+                .child(
+                    div()
+                        .flex()
+                        .items_center()
+                        .gap(px(6.))
+                        .child(button("packs-add", "Add pack…", Kind::Ghost, &t).on_click(
+                            cx.listener(|this, _: &ClickEvent, _, cx| {
+                                this.choose_packs(cx);
+                                cx.notify();
+                            }),
+                        ))
+                        .child(
+                            button("packs-folder", "Open folder", Kind::Ghost, &t).on_click(
+                                move |_, _, cx| {
+                                    let dir = home.join(PackKind::Resource.folder());
+                                    let _ = std::fs::create_dir_all(&dir);
+                                    cx.open_with_system(&dir);
+                                },
+                            ),
+                        ),
+                );
+        let mut section = div()
+            .id("packs")
+            .flex()
+            .flex_col()
+            .gap(px(8.))
+            // The drop outline sits just outside the rows, which line up with the other sections.
+            .p(px(2.))
+            .mx(px(-4.))
+            .border_2()
+            .border_color(gpui::transparent_black())
+            .drag_over::<ExternalPaths>(move |s, _, _, _| s.border_color(t.accent).bg(t.well))
+            .on_drop(cx.listener(|this, paths: &ExternalPaths, _, cx| {
+                this.add_packs(paths.paths().to_vec());
+                // Not the window's import as well.
+                cx.stop_propagation();
+                cx.notify();
+            }))
+            .child(header);
+        match &self.game_packs.note {
+            Some(Ok(m)) => {
+                section = section.child(text(theme::CAPTION).text_color(t.muted).child(m.clone()))
+            }
+            Some(Err(e)) => section = section.child(notice(e.clone(), &t)),
+            None => {}
+        }
+        if self.client.is_some() {
+            section = section.child(text(theme::CAPTION).text_color(t.muted).child(
+                "The game is running: change packs in its own menus, or here once it is closed.",
+            ));
+        }
+        let resource = self.game_packs.resource.clone();
+        section = section.child(caps("Resource packs").text_color(t.muted).mt(px(4.)));
+        if resource.is_empty() {
+            section = section.child(
+                text(theme::CAPTION)
+                    .text_color(t.muted)
+                    .child("None yet: drop a .zip here, or find some on the Mods page."),
+            );
+        }
+        for (i, (pack, icon)) in resource.into_iter().enumerate() {
+            section = section.child(self.pack_row(i, pack, icon, cx));
+        }
+        let shader = self.game_packs.shader.clone();
+        section = section.child(caps("Shader packs").text_color(t.muted).mt(px(8.)));
+        if shader.is_empty() {
+            section = section.child(
+                text(theme::CAPTION)
+                    .text_color(t.muted)
+                    .child("None yet: drop a .hshader or a shader pack .zip here."),
+            );
+        }
+        for (i, pack) in shader.into_iter().enumerate() {
+            section = section.child(self.pack_row(i, pack, None, cx));
+        }
+        Some(section)
+    }
+
+    fn pack_row(
+        &mut self,
+        i: usize,
+        pack: Pack,
+        icon: Option<Arc<Image>>,
+        cx: &mut Context<Self>,
+    ) -> Div {
+        let t = self.theme;
+        let id = |what: &str| {
+            SharedString::from(format!("pack-{what}-{:?}-{i}", pack.kind).to_lowercase())
+        };
+        let picture = div()
+            .flex()
+            .flex_none()
+            .items_center()
+            .justify_center()
+            .size(px(40.))
+            .border_2()
+            .border_color(t.outline)
+            .bg(t.well);
+        let picture = match icon {
+            Some(image) => picture.child(gpui::img(image).size(px(36.))),
+            None => picture.child(blocks::icon(
+                if pack.kind == PackKind::Shader {
+                    "zap"
+                } else {
+                    "package"
+                },
+                18.,
+                t.muted,
+            )),
+        };
+        let running = self.client.is_some();
+        let mut actions = div().flex().items_center().gap(px(6.));
+        let key = (pack.kind, pack.file.clone());
+        if self.game_packs.confirm_remove.as_ref() == Some(&key) {
+            let gone = pack.clone();
+            actions = actions
+                .child(
+                    text(theme::CAPTION)
+                        .text_color(t.danger)
+                        .child("Move it to the trash?"),
+                )
+                .child(
+                    button(id("keep"), "Keep", Kind::Ghost, &t).on_click(cx.listener(
+                        |this, _: &ClickEvent, _, cx| {
+                            this.game_packs.confirm_remove = None;
+                            cx.notify();
+                        },
+                    )),
+                )
+                .child(
+                    button(id("trash"), "Move to trash", Kind::Secondary, &t).on_click(
+                        cx.listener(move |this, _: &ClickEvent, _, cx| {
+                            let gone = gone.clone();
+                            this.pack_action(move |home| {
+                                packs::remove(home, &gone)
+                                    .map(|()| format!("{} moved to the trash.", gone.title))
+                            });
+                            cx.notify();
+                        }),
+                    ),
+                );
+        } else {
+            let toggle = switch(id("toggle"), pack.enabled, &t);
+            let flip = pack.clone();
+            let toggle = if running {
+                disabled(toggle)
+            } else {
+                toggle.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                    let flip = flip.clone();
+                    this.pack_action(move |home| {
+                        packs::set_enabled(home, &flip, !flip.enabled).map(|()| {
+                            match flip.enabled {
+                                true => format!("{} is off.", flip.title),
+                                false => format!("{} is on.", flip.title),
+                            }
+                        })
+                    });
+                    cx.notify();
+                }))
+            };
+            let remove = button(id("remove"), "Remove", Kind::Ghost, &t);
+            let remove = if running {
+                disabled(remove)
+            } else {
+                remove.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                    this.game_packs.confirm_remove = Some(key.clone());
+                    cx.notify();
+                }))
+            };
+            actions = actions.child(toggle).child(remove);
+        }
+        let facts = match pack.description.is_empty() {
+            true => pack.file.clone(),
+            false if pack.title == pack.file => pack.description.clone(),
+            false => format!("{} · {}", pack.description, pack.file),
+        };
+        plate(&t)
+            .flex()
+            .items_center()
+            .gap(px(14.))
+            .px(px(14.))
+            .py(px(8.))
+            .child(picture)
+            .child(
+                div()
+                    .flex()
+                    .flex_col()
+                    .flex_1()
+                    .min_w_0()
+                    .child(
+                        blocks::pixel(14., FontWeight::MEDIUM)
+                            .text_color(if pack.enabled { t.ink } else { t.muted })
+                            .truncate()
+                            .child(pack.title.clone()),
+                    )
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.muted)
+                            .truncate()
+                            .child(facts),
+                    ),
+            )
+            .child(actions)
+    }
+}
diff --git a/launcher/src/partner.rs b/launcher/src/partner.rs
index eea1a3524..ae82ebd7f 100644
--- a/launcher/src/partner.rs
+++ b/launcher/src/partner.rs
@@ -1,12 +1,20 @@
-//! Sculk's banner: a server host that sponsors Horizon (Ludovic, 2026-10-26), on the Servers page
-//! and under Home's rows. The picture is in the binary, never fetched; a click opens Sculk's page in
-//! the browser. A "Partner" label above it says it is an ad.
+//! Sculk, a server host that sponsors Horizon (Ludovic, 2026-10-26): its wide banner on the Servers
+//! page, and a card made for the sidebar on the other pages, where the banner's baked-in text was too
+//! small to read. The pictures are in the binary, never fetched; a click opens Sculk's page in the
+//! browser. A "Partner" label above each says it is an ad.
 use crate::theme::Theme;
-use gpui::{div, img, prelude::*, px, ClickEvent, Div, Image, ImageFormat, Stateful};
+use gpui::{
+    div, img, prelude::*, px, rgb, ClickEvent, Div, FontWeight, HighlightStyle, Image, ImageFormat,
+    Rgba, SharedString, Stateful, StyledText,
+};
 use std::sync::{Arc, LazyLock};
 
 pub const URL: &str = "https://my.sculkhosting.com/ref/horizon";
 
+/// How long the sidebar's banner stays on screen, counted over every start, before a "Hide" shows
+/// beside its label: long enough to be seen, then the player may put it away for good.
+pub const SEEN_BEFORE_HIDE: u64 = 180;
+
 /// 1200×441: twice the widest it is shown at, for Retina screens. Its transparent edges let the
 /// characters stand out of the card.
 const WIDTH: f32 = 1200.;
@@ -19,7 +27,7 @@ static BANNER: LazyLock<Arc<Image>> = LazyLock::new(|| {
 });
 
 /// The banner `width` logical pixels wide, under its label. Hovering lifts it a little and turns the
-/// label to ink. The narrowest window (960) leaves the page 648 pixels, so it always fits.
+/// label to ink. The narrowest window (960) leaves the page 648 pixels, so the Servers one always fits.
 pub fn banner(id: &'static str, width: f32, t: &Theme) -> Stateful<Div> {
     let t = *t;
     let el = div()
@@ -34,7 +42,7 @@ pub fn banner(id: &'static str, width: f32, t: &Theme) -> Stateful<Div> {
             crate::text(crate::theme::MICRO)
                 .text_color(t.muted)
                 .group_hover(id, move |s| s.text_color(t.ink))
-                .child("PARTNER"),
+                .child(horizon_launcher::i18n::tr("PARTNER")),
         )
         .child(
             div().relative().group_hover(id, |s| s.top(px(-2.))).child(
@@ -47,9 +55,256 @@ pub fn banner(id: &'static str, width: f32, t: &Theme) -> Stateful<Div> {
     crate::keyboard(el, &t)
 }
 
+/// Sculk's characters (Steve, Alex and the wolf) cropped from its banner at 2x the card's width.
+/// Above `ART_TOP` (in the card's 228 logical pixels) the picture is transparent but for their heads
+/// and the pickaxe, which stand out of the card; its foot and right edge fade into `CARD`.
+const ART_WIDTH: f32 = 456.;
+const ART_HEIGHT: f32 = 364.;
+const ART_TOP: f32 = 11.;
+static ART: LazyLock<Arc<Image>> = LazyLock::new(|| {
+    Arc::new(Image::from_bytes(
+        ImageFormat::Webp,
+        include_bytes!("../assets/sculk-card-art.webp").to_vec(),
+    ))
+});
+
+/// Sculk's mark and name, cropped from its banner, 2x for a 18 pixel height.
+const LOGO_WIDTH: f32 = 191.;
+const LOGO_HEIGHT: f32 = 36.;
+static LOGO: LazyLock<Arc<Image>> = LazyLock::new(|| {
+    Arc::new(Image::from_bytes(
+        ImageFormat::Webp,
+        include_bytes!("../assets/sculk-logo.webp").to_vec(),
+    ))
+});
+
+/// Sculk's colours, taken from its banner: the card is Sculk's in both themes, as an ad is.
+const CARD: u32 = 0x0b0d12;
+const CYAN: u32 = 0x5dd4fb;
+const CYAN_HOVER: u32 = 0x8fe3fd;
+const WHITE: u32 = 0xf1f5f9;
+const GREY: u32 = 0x9aa6b2;
+const ON_CYAN: u32 = 0x062330;
+
+/// The promo code: Sculk's, never translated.
+const CODE: &str = "HORIZON15";
+
+/// What the tall card needs of the sidebar's height, label included, with room for a third line of
+/// headline: below it the sidebar shows the compact card.
+pub const TALL_HEIGHT: f32 = 410.;
+
+/// "Your Minecraft server, 24/7 online." with "24/7 online" in Sculk's cyan, in the launcher's
+/// language.
+fn headline() -> StyledText {
+    let online = horizon_launcher::i18n::tr("24/7 online");
+    let line = horizon_launcher::i18n::tr("Your Minecraft server, {online}.");
+    let (before, after) = line.split_once("{online}").unwrap_or((line, ""));
+    let text = format!("{before}{online}{after}");
+    let lit = before.len()..before.len() + online.len();
+    StyledText::new(SharedString::from(text)).with_highlights([(
+        lit,
+        HighlightStyle {
+            color: Some(rgb(CYAN).into()),
+            ..Default::default()
+        },
+    )])
+}
+
+/// "HORIZON15 · 15% off" in a dashed cyan frame, as on Sculk's banner.
+fn code_chip(size: f32, height: f32) -> Div {
+    div()
+        .flex()
+        .items_center()
+        .justify_center()
+        .gap(px(6.))
+        .h(px(height))
+        .px(px(10.))
+        .border_1()
+        .border_dashed()
+        .border_color(rgba(CYAN, 0.7))
+        .rounded(px(6.))
+        .font_family(crate::theme::MONO)
+        .text_size(px(size))
+        .whitespace_nowrap()
+        .child(
+            div()
+                .text_color(rgb(WHITE))
+                .font_weight(FontWeight::SEMIBOLD)
+                .child(CODE),
+        )
+        .child(div().text_color(rgb(GREY)).child("·"))
+        .child(
+            div()
+                .text_color(rgb(CYAN))
+                .child(horizon_launcher::i18n::tr("15% off")),
+        )
+}
+
+fn rgba(hex: u32, alpha: f32) -> Rgba {
+    Rgba {
+        a: alpha,
+        ..rgb(hex)
+    }
+}
+
+/// Sculk's card for the sidebar, `width` logical pixels wide: its characters standing out of the top,
+/// then its name, the headline, a line, a "Get my server" button and the promo code, all drawn by
+/// the launcher so they stay sharp and follow its language. `compact` puts the characters beside a
+/// shorter text, for windows too short for the tall card. Hovering lifts it a little.
+pub fn card(id: &'static str, width: f32, compact: bool, t: &Theme) -> Stateful<Div> {
+    let t = *t;
+    let label = crate::text(crate::theme::MICRO)
+        .text_color(t.muted)
+        .group_hover(id, move |s| s.text_color(t.ink))
+        .child(horizon_launcher::i18n::tr("PARTNER"));
+    let face = div()
+        .relative()
+        .flex()
+        .flex_none()
+        .w(px(width))
+        .bg(rgb(CARD))
+        .border_1()
+        .border_color(rgba(CYAN, 0.22))
+        .rounded(px(10.))
+        .group_hover(id, |s| s.top(px(-2.)).border_color(rgba(CYAN, 0.5)));
+    let logo = |height: f32| {
+        img(LOGO.clone())
+            .flex_none()
+            .w(px(height * LOGO_WIDTH / LOGO_HEIGHT))
+            .h(px(height))
+    };
+    let face = if compact {
+        // The characters beside the text, their faded foot melting into the card, the code under both.
+        let art_w = 104.;
+        face.flex_col()
+            .child(
+                div()
+                    .flex()
+                    .items_end()
+                    .child(
+                        div()
+                            .flex()
+                            .flex_col()
+                            .flex_1()
+                            .min_w_0()
+                            .gap(px(8.))
+                            .pl(px(12.))
+                            .pt(px(12.))
+                            .child(logo(13.))
+                            .child(
+                                div()
+                                    .text_size(px(15.))
+                                    .line_height(px(19.))
+                                    .font_weight(FontWeight::SEMIBOLD)
+                                    .text_color(rgb(WHITE))
+                                    .child(headline()),
+                            ),
+                    )
+                    .child(
+                        img(ART.clone())
+                            .flex_none()
+                            .w(px(art_w))
+                            .h(px(art_w * ART_HEIGHT / ART_WIDTH)),
+                    ),
+            )
+            .child(
+                div()
+                    .flex()
+                    .px(px(12.))
+                    .pt(px(6.))
+                    .pb(px(12.))
+                    .child(code_chip(11., 26.).flex_1()),
+            )
+    } else {
+        let art_h = width * ART_HEIGHT / ART_WIDTH;
+        let button = div()
+            .flex()
+            .items_center()
+            .justify_center()
+            .h(px(36.))
+            .rounded(px(8.))
+            .bg(rgb(CYAN))
+            .group_hover(id, |s| s.bg(rgb(CYAN_HOVER)))
+            .text_color(rgb(ON_CYAN))
+            .text_size(px(14.))
+            .font_weight(FontWeight::SEMIBOLD)
+            .child(horizon_launcher::i18n::tr("Get my server"));
+        // The art stands out of the card's top; the text starts over its faded foot.
+        face.mt(px(ART_TOP))
+            .flex_col()
+            .child(
+                img(ART.clone())
+                    .absolute()
+                    .top(px(-ART_TOP))
+                    .left_0()
+                    .w(px(width))
+                    .h(px(art_h)),
+            )
+            .child(
+                div()
+                    .flex()
+                    .flex_col()
+                    .pt(px(art_h - ART_TOP - 14.))
+                    .px(px(16.))
+                    .pb(px(16.))
+                    .child(logo(16.))
+                    .child(
+                        div()
+                            .mt(px(12.))
+                            .text_size(px(19.))
+                            .line_height(px(23.))
+                            .font_weight(FontWeight::SEMIBOLD)
+                            .text_color(rgb(WHITE))
+                            .child(headline()),
+                    )
+                    .child(
+                        div()
+                            .mt(px(6.))
+                            .text_size(px(13.))
+                            .line_height(px(18.))
+                            .text_color(rgb(GREY))
+                            .child(horizon_launcher::i18n::tr("Ready in under a minute")),
+                    )
+                    .child(div().mt(px(16.)).child(button))
+                    .child(div().mt(px(8.)).flex().child(code_chip(12., 30.).flex_1())),
+            )
+    };
+    let el = div()
+        .id(id)
+        .group(id)
+        .flex()
+        .flex_col()
+        .gap(px(8.))
+        .w(px(width))
+        .cursor_pointer()
+        .child(label)
+        .child(face)
+        .on_click(|_: &ClickEvent, _, cx| cx.open_url(URL));
+    crate::keyboard(el, &t)
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{HEIGHT, WIDTH};
+    use super::{ART_HEIGHT, ART_WIDTH, HEIGHT, LOGO_HEIGHT, LOGO_WIDTH, WIDTH};
+
+    /// Each bundled picture decodes as a WebP of the size the code lays it out at.
+    #[test]
+    fn the_card_pictures_decode() {
+        for (bytes, size) in [
+            (
+                &include_bytes!("../assets/sculk-card-art.webp")[..],
+                (ART_WIDTH, ART_HEIGHT),
+            ),
+            (
+                &include_bytes!("../assets/sculk-logo.webp")[..],
+                (LOGO_WIDTH, LOGO_HEIGHT),
+            ),
+        ] {
+            let pic = image::load_from_memory_with_format(bytes, image::ImageFormat::WebP)
+                .expect("a WebP");
+            assert_eq!((pic.width(), pic.height()), (size.0 as u32, size.1 as u32));
+        }
+    }
 
     #[test]
     fn the_bundled_banner_decodes() {
diff --git a/launcher/src/screenshots.rs b/launcher/src/screenshots.rs
new file mode 100644
index 000000000..1d7c79fe1
--- /dev/null
+++ b/launcher/src/screenshots.rs
@@ -0,0 +1,103 @@
+//! An instance's screenshots: the pictures F2 saves into `screenshots/` in its game folder
+//! (vanilla's `Screenshot.grab`, named `<yyyy-MM-dd_HH.mm.ss>.png`).
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::time::SystemTime;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Shot {
+    pub path: PathBuf,
+    /// Its file name, the id commands take.
+    pub name: String,
+    /// When the file was written.
+    pub taken: SystemTime,
+    pub size: u64,
+}
+
+/// The folder F2 saves into for the game folder `home`.
+pub fn folder(home: &Path) -> PathBuf {
+    home.join("screenshots")
+}
+
+/// The pictures in `home`'s screenshots folder, the newest first.
+pub fn list(home: &Path) -> Vec<Shot> {
+    let mut shots: Vec<Shot> = fs::read_dir(folder(home))
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter_map(|e| {
+            let path = e.path();
+            let picture = path
+                .extension()
+                .and_then(|x| x.to_str())
+                .is_some_and(|x| ["png", "jpg", "jpeg"].contains(&x.to_ascii_lowercase().as_str()));
+            let meta = e.metadata().ok().filter(|m| m.is_file() && picture)?;
+            Some(Shot {
+                name: e.file_name().to_string_lossy().into_owned(),
+                taken: meta.modified().unwrap_or(SystemTime::UNIX_EPOCH),
+                size: meta.len(),
+                path,
+            })
+        })
+        .collect();
+    // Same second: the game names the next ones `_2`, `_3`..., which sort after the first.
+    shots.sort_by(|a, b| b.taken.cmp(&a.taken).then_with(|| b.name.cmp(&a.name)));
+    shots
+}
+
+/// The screenshot a command names: its file name, with or without the extension.
+pub fn find(home: &Path, query: &str) -> Result<Shot, String> {
+    list(home)
+        .into_iter()
+        .find(|s| s.name == query || Path::new(&s.name).file_stem().is_some_and(|n| n == query))
+        .ok_or_else(|| format!("No screenshot {query} in {}", folder(home).display()))
+}
+
+/// Moves the screenshot to the system's trash.
+pub fn delete(shot: &Shot) -> Result<(), String> {
+    crate::desktop_seams::to_trash(&shot.path)
+        .map_err(|e| format!("Could not move {} to the trash: {e}", shot.name))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Duration;
+
+    #[test]
+    fn lists_pictures_newest_first() {
+        let home =
+            std::env::temp_dir().join(format!("horizon-launcher-shots-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&home);
+        let dir = folder(&home);
+        fs::create_dir_all(dir.join("not-a-picture.png")).unwrap();
+        let base = SystemTime::UNIX_EPOCH + Duration::from_secs(1_800_000_000);
+        for (name, age) in [
+            ("2026-10-25_20.00.01.png", 60),
+            ("2026-10-27_09.15.42.png", 0),
+            ("2026-10-27_09.15.42_2.png", 0),
+            ("notes.txt", 0),
+            ("Edited.JPG", 30),
+        ] {
+            let path = dir.join(name);
+            fs::write(&path, b"x").unwrap();
+            let file = fs::File::options().write(true).open(&path).unwrap();
+            file.set_modified(base - Duration::from_secs(age)).unwrap();
+        }
+        let names: Vec<_> = list(&home).into_iter().map(|s| s.name).collect();
+        assert_eq!(
+            names,
+            [
+                "2026-10-27_09.15.42_2.png",
+                "2026-10-27_09.15.42.png",
+                "Edited.JPG",
+                "2026-10-25_20.00.01.png"
+            ]
+        );
+        assert_eq!(find(&home, "2026-10-25_20.00.01").unwrap().size, 1);
+        assert_eq!(find(&home, "Edited.JPG").unwrap().name, "Edited.JPG");
+        assert!(find(&home, "notes.txt").is_err());
+        assert!(list(&home.join("none")).is_empty());
+        fs::remove_dir_all(&home).unwrap();
+    }
+}
diff --git a/launcher/src/screenshots_page.rs b/launcher/src/screenshots_page.rs
new file mode 100644
index 000000000..d4017ade1
--- /dev/null
+++ b/launcher/src/screenshots_page.rs
@@ -0,0 +1,325 @@
+//! The selected instance's screenshots on Home (`horizon_launcher::screenshots`): the newest as
+//! thumbnails, all of them on request, and a viewer (← and → step through) with Copy, Open,
+//! Show in folder and Delete (to the trash, after a confirmation).
+use super::*;
+use gpui::{ClipboardItem, Image, ImageFormat};
+use horizon_launcher::screenshots::{self, Shot};
+use std::path::PathBuf;
+
+/// Thumbnails shown before "Show all".
+const FIRST: usize = 8;
+const THUMB_W: f32 = 196.;
+const THUMB_H: f32 = THUMB_W * 9. / 16.;
+
+#[derive(Default)]
+pub(super) struct Screenshots {
+    home: Option<PathBuf>,
+    list: Vec<Shot>,
+    fresh: bool,
+    all: bool,
+    /// The picture open in the viewer, by its place in `list`.
+    viewing: Option<usize>,
+    confirm_delete: bool,
+    /// What the last action did, or why it failed.
+    note: Option<Result<String, String>>,
+}
+
+impl Screenshots {
+    /// Read again on the next frame: the game may have taken new ones.
+    pub(super) fn stale(&mut self) {
+        self.fresh = false;
+    }
+}
+
+impl Launcher {
+    fn load_screenshots(&mut self, home: PathBuf) {
+        if self.screenshots.home.as_ref() != Some(&home) {
+            self.screenshots = Screenshots {
+                home: Some(home.clone()),
+                ..Screenshots::default()
+            };
+        }
+        if !self.screenshots.fresh {
+            // One directory listing: cheap enough while drawing.
+            self.screenshots.list = screenshots::list(&home);
+            self.screenshots.fresh = true;
+            let last = self.screenshots.list.len().checked_sub(1);
+            self.screenshots.viewing = self
+                .screenshots
+                .viewing
+                .and_then(|i| last.map(|l| i.min(l)));
+        }
+    }
+
+    /// Escape closes the viewer. Whether it did.
+    pub(super) fn screenshot_escape(&mut self) -> bool {
+        let open = self.screenshots.viewing.take().is_some();
+        self.screenshots.confirm_delete = false;
+        open
+    }
+
+    /// ← and → in the viewer: the newer and the older picture. Whether it moved.
+    pub(super) fn screenshot_step(&mut self, older: bool) -> bool {
+        let Some(i) = self.screenshots.viewing else {
+            return false;
+        };
+        let next = match older {
+            true => (i + 1 < self.screenshots.list.len()).then_some(i + 1),
+            false => i.checked_sub(1),
+        };
+        if let Some(n) = next {
+            self.screenshots.viewing = Some(n);
+            self.screenshots.confirm_delete = false;
+            self.screenshots.note = None;
+        }
+        true
+    }
+
+    fn copy_screenshot(&mut self, shot: &Shot, cx: &mut Context<Self>) {
+        let format = match shot.path.extension().and_then(|x| x.to_str()) {
+            Some(x) if x.eq_ignore_ascii_case("png") => ImageFormat::Png,
+            _ => ImageFormat::Jpeg,
+        };
+        self.screenshots.note = Some(match std::fs::read(&shot.path) {
+            Ok(bytes) => {
+                copy_to_clipboard(
+                    cx,
+                    ClipboardItem::new_image(&Image::from_bytes(format, bytes)),
+                );
+                Ok("Copied to the clipboard.".into())
+            }
+            Err(e) => Err(format!("Could not read {}: {e}", shot.name)),
+        });
+    }
+
+    fn delete_screenshot(&mut self, shot: &Shot) {
+        self.screenshots.confirm_delete = false;
+        self.screenshots.note =
+            Some(screenshots::delete(shot).map(|()| format!("{} moved to the trash.", shot.name)));
+        self.screenshots.stale();
+    }
+
+    /// Home's Screenshots section, for the selected instance; None while it has none.
+    pub(super) fn screenshots_section(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let home = self.selected_instance()?.home.clone();
+        self.load_screenshots(home.clone());
+        let list = self.screenshots.list.clone();
+        if list.is_empty() {
+            return None;
+        }
+        let shown = if self.screenshots.all {
+            list.len()
+        } else {
+            FIRST
+        };
+        let folder = screenshots::folder(&home);
+        let mut buttons = div().flex().items_center().gap(px(6.));
+        if list.len() > FIRST {
+            let label = match self.screenshots.all {
+                true => "Show fewer".to_string(),
+                false => format!("Show all {}", list.len()),
+            };
+            buttons = buttons.child(button("screenshots-all", label, Kind::Ghost, &t).on_click(
+                cx.listener(|this, _: &ClickEvent, _, cx| {
+                    this.screenshots.all = !this.screenshots.all;
+                    cx.notify();
+                }),
+            ));
+        }
+        buttons = buttons.child(
+            button("screenshots-folder", "Open folder", Kind::Ghost, &t)
+                .on_click(move |_, _, cx| cx.open_with_system(&folder)),
+        );
+        let header = div()
+            .flex()
+            .items_center()
+            .justify_between()
+            .mb(px(4.))
+            .child(section_title("Screenshots", "image", &t))
+            .child(buttons);
+        let grid = div().flex().flex_wrap().gap(px(10.)).children(
+            list.into_iter().take(shown).enumerate().map(|(i, shot)| {
+                div()
+                    .id(SharedString::from(format!("screenshot-{i}")))
+                    .flex_none()
+                    .w(px(THUMB_W))
+                    .h(px(THUMB_H))
+                    .border_2()
+                    .border_color(t.outline)
+                    .bg(t.well)
+                    .cursor_pointer()
+                    .hover(|s| s.border_color(t.accent))
+                    .child(
+                        gpui::img(shot.path.clone())
+                            .size_full()
+                            .object_fit(gpui::ObjectFit::Cover),
+                    )
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        this.screenshots.viewing = Some(i);
+                        this.screenshots.confirm_delete = false;
+                        this.screenshots.note = None;
+                        cx.notify();
+                    }))
+            }),
+        );
+        let mut section = div().flex().flex_col().gap(px(8.)).child(header);
+        if self.screenshots.viewing.is_none() {
+            if let Some(Err(e)) = &self.screenshots.note {
+                section = section.child(notice(e.clone(), &t));
+            }
+        }
+        Some(section.child(grid))
+    }
+
+    /// The viewer over the whole window, while a picture is open.
+    pub(super) fn screenshot_viewer(&mut self, cx: &mut Context<Self>) -> Option<Stateful<Div>> {
+        let t = self.theme;
+        let i = self.screenshots.viewing?;
+        let shot = self.screenshots.list.get(i)?.clone();
+        let count = self.screenshots.list.len();
+        let taken: chrono::DateTime<chrono::Local> = shot.taken.into();
+        let step = |id: &'static str, label: &'static str, older: bool, can: bool| {
+            let b = button(id, label, Kind::Ghost, &t);
+            if can {
+                b.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                    this.screenshot_step(older);
+                    cx.notify();
+                }))
+            } else {
+                disabled(b)
+            }
+        };
+        let mut actions = div().flex().items_center().gap(px(6.));
+        if self.screenshots.confirm_delete {
+            let gone = shot.clone();
+            actions =
+                actions
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.danger)
+                            .child("Move it to the trash?"),
+                    )
+                    .child(button("screenshot-keep", "Keep", Kind::Ghost, &t).on_click(
+                        cx.listener(|this, _: &ClickEvent, _, cx| {
+                            this.screenshots.confirm_delete = false;
+                            cx.notify();
+                        }),
+                    ))
+                    .child(
+                        button("screenshot-trash", "Move to trash", Kind::Secondary, &t).on_click(
+                            cx.listener(move |this, _: &ClickEvent, _, cx| {
+                                this.delete_screenshot(&gone);
+                                cx.notify();
+                            }),
+                        ),
+                    );
+        } else {
+            let (copy, open, show) = (shot.clone(), shot.path.clone(), shot.path.clone());
+            actions =
+                actions
+                    .child(button("screenshot-copy", "Copy", Kind::Ghost, &t).on_click(
+                        cx.listener(move |this, _: &ClickEvent, _, cx| {
+                            this.copy_screenshot(&copy, cx);
+                            cx.notify();
+                        }),
+                    ))
+                    .child(
+                        button("screenshot-open", "Open", Kind::Ghost, &t)
+                            .on_click(move |_, _, cx| cx.open_with_system(&open)),
+                    )
+                    .child(
+                        button("screenshot-show", "Show in folder", Kind::Ghost, &t)
+                            .on_click(move |_, _, cx| cx.reveal_path(&show)),
+                    )
+                    .child(
+                        button("screenshot-delete", "Delete", Kind::Ghost, &t).on_click(
+                            cx.listener(|this, _: &ClickEvent, _, cx| {
+                                this.screenshots.confirm_delete = true;
+                                cx.notify();
+                            }),
+                        ),
+                    );
+        }
+        let note = match &self.screenshots.note {
+            Some(Ok(m)) => Some(text(theme::CAPTION).text_color(t.muted).child(m.clone())),
+            Some(Err(e)) => Some(text(theme::CAPTION).text_color(t.danger).child(e.clone())),
+            None => None,
+        };
+        let top = div()
+            .flex()
+            .items_center()
+            .gap(px(12.))
+            .child(
+                div()
+                    .flex()
+                    .flex_col()
+                    .flex_1()
+                    .min_w_0()
+                    .child(
+                        blocks::pixel(17., FontWeight::MEDIUM)
+                            .text_color(t.ink)
+                            .child(taken.format("%Y-%m-%d %H:%M:%S").to_string()),
+                    )
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.muted)
+                            .truncate()
+                            .child(format!("{} · {} of {count}", shot.name, i + 1)),
+                    ),
+            )
+            .child(step("screenshot-newer", "← Newer", false, i > 0))
+            .child(step("screenshot-older", "Older →", true, i + 1 < count))
+            .child(
+                button("screenshot-close", "Close", Kind::Secondary, &t).on_click(cx.listener(
+                    |this, _: &ClickEvent, _, cx| {
+                        this.screenshot_escape();
+                        cx.notify();
+                    },
+                )),
+            );
+        let bottom = div()
+            .flex()
+            .items_center()
+            .justify_between()
+            .gap(px(12.))
+            .child(div().children(note))
+            .child(actions);
+        Some(
+            div()
+                .id("screenshot-viewer")
+                .absolute()
+                .top_0()
+                .left_0()
+                .size_full()
+                .flex()
+                .flex_col()
+                .gap(px(14.))
+                .px(px(32.))
+                .py(px(24.))
+                .bg(t.page.opacity(0.96))
+                .on_scroll_wheel(|_, _, cx| cx.stop_propagation())
+                .occlude()
+                .child(top)
+                .child(
+                    // The picture fills what the bars leave, whatever its own size.
+                    div()
+                        .relative()
+                        .flex_1()
+                        .min_h_0()
+                        .border_2()
+                        .border_color(t.outline)
+                        .bg(t.well)
+                        .child(
+                            gpui::img(shot.path.clone())
+                                .absolute()
+                                .top_0()
+                                .left_0()
+                                .size_full()
+                                .object_fit(gpui::ObjectFit::Contain),
+                        ),
+                )
+                .child(bottom),
+        )
+    }
+}
diff --git a/launcher/src/server_list.rs b/launcher/src/server_list.rs
new file mode 100644
index 000000000..896877df4
--- /dev/null
+++ b/launcher/src/server_list.rs
@@ -0,0 +1,159 @@
+//! The player's server list, `servers.dat` in an instance's game folder: the game's Multiplayer
+//! screen reads and writes the same file. Its format is vanilla's (`ServerList.load`/`save`,
+//! `ServerData.read`/`write`): uncompressed NBT, `servers` a list of compounds with `name`, `ip`,
+//! an optional `icon` (a PNG in base64), `acceptTextures`, `acceptedCodeOfConduct` and `hidden`.
+//! The launcher only adds and removes entries: every other field of every entry is written back
+//! as it was read.
+use base64::Engine;
+use horizon_world::nbt::{self, Compound, JavaString, Limits, NamedTag, Tag};
+use std::fs;
+use std::path::Path;
+
+const FILE: &str = "servers.dat";
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Server {
+    pub name: String,
+    pub ip: String,
+    /// The server's picture, as the game last saw it (PNG).
+    pub icon: Option<Vec<u8>>,
+}
+
+/// The entries as they are in the file, the hidden ones (servers joined with Direct
+/// Connection) too.
+pub struct List {
+    entries: Vec<Compound>,
+}
+
+fn key(k: &str) -> JavaString {
+    JavaString::from(k)
+}
+
+fn text(entry: &Compound, k: &str) -> String {
+    match entry.get(&key(k)) {
+        Some(Tag::String(s)) => s.to_string_lossy(),
+        _ => String::new(),
+    }
+}
+
+fn hidden(entry: &Compound) -> bool {
+    matches!(entry.get(&key("hidden")), Some(Tag::Byte(b)) if *b != 0)
+}
+
+impl List {
+    /// The list in `home`; empty when there is none or it can't be read, as the game does.
+    pub fn load(home: &Path) -> List {
+        let entries = fs::read(home.join(FILE))
+            .ok()
+            .and_then(|bytes| nbt::read_named(&bytes, Limits::default()).ok())
+            .and_then(|(root, _)| match root.tag.get("servers") {
+                Some(Tag::List(list)) => Some(
+                    list.iter()
+                        .filter_map(|t| match t {
+                            Tag::Compound(c) => Some(c.clone()),
+                            _ => None,
+                        })
+                        .collect(),
+                ),
+                _ => None,
+            })
+            .unwrap_or_default();
+        List { entries }
+    }
+
+    /// The servers the Multiplayer screen shows, in its order.
+    pub fn servers(&self) -> Vec<Server> {
+        self.entries
+            .iter()
+            .filter(|e| !hidden(e))
+            .map(|e| Server {
+                name: text(e, "name"),
+                ip: text(e, "ip"),
+                icon: Some(text(e, "icon"))
+                    .filter(|s| !s.is_empty())
+                    .and_then(|s| base64::engine::general_purpose::STANDARD.decode(s).ok()),
+            })
+            .collect()
+    }
+
+    /// Adds a server at the end of the shown ones, as the game's Add Server does.
+    pub fn add(&mut self, name: &str, ip: &str) -> Result<(), String> {
+        let (name, ip) = (name.trim(), ip.trim());
+        if ip.is_empty() {
+            return Err("A server needs an address.".into());
+        }
+        let name = if name.is_empty() {
+            "Minecraft Server"
+        } else {
+            name
+        };
+        let at = self
+            .entries
+            .iter()
+            .rposition(|e| !hidden(e))
+            .map_or(0, |i| i + 1);
+        let entry: Compound = [
+            (key("name"), Tag::String(name.into())),
+            (key("ip"), Tag::String(ip.into())),
+            (key("hidden"), Tag::Byte(0)),
+        ]
+        .into_iter()
+        .collect();
+        self.entries.insert(at, entry);
+        Ok(())
+    }
+
+    /// Removes the `index`th shown server.
+    pub fn remove(&mut self, index: usize) -> Result<Server, String> {
+        let server = self
+            .servers()
+            .into_iter()
+            .nth(index)
+            .ok_or_else(|| format!("There is no server {}.", index + 1))?;
+        let at = (0..self.entries.len())
+            .filter(|&i| !hidden(&self.entries[i]))
+            .nth(index)
+            .unwrap();
+        self.entries.remove(at);
+        Ok(server)
+    }
+
+    /// Writes the list as the game does: a new file first, the old one kept as `servers.dat_old`.
+    pub fn save(&self, home: &Path) -> Result<(), String> {
+        let root = NamedTag {
+            name: "".into(),
+            tag: Tag::compound([(
+                "servers",
+                Tag::List(self.entries.iter().cloned().map(Tag::Compound).collect()),
+            )]),
+        };
+        let bytes = nbt::write_named(&root, Limits::default()).map_err(|e| e.to_string())?;
+        let (new, current) = (home.join("servers.dat_new"), home.join(FILE));
+        let written = fs::create_dir_all(home)
+            .and_then(|()| fs::write(&new, bytes))
+            .and_then(|()| match current.exists() {
+                true => fs::copy(&current, home.join("servers.dat_old")).map(|_| ()),
+                false => Ok(()),
+            })
+            .and_then(|()| fs::rename(&new, &current));
+        written.map_err(|e| format!("Could not save the server list: {e}"))
+    }
+}
+
+/// The shown server a command names: its position from 1, its name (any case) or its address.
+pub fn find(list: &List, query: &str) -> Result<(usize, Server), String> {
+    let servers = list.servers();
+    let q = query.trim();
+    q.parse::<usize>()
+        .ok()
+        .filter(|n| (1..=servers.len()).contains(n))
+        .map(|n| n - 1)
+        .or_else(|| servers.iter().position(|s| s.name.eq_ignore_ascii_case(q)))
+        .or_else(|| servers.iter().position(|s| s.ip.eq_ignore_ascii_case(q)))
+        .map(|i| (i, servers[i].clone()))
+        .ok_or_else(|| format!("No server {q} in the list"))
+}
+
+#[cfg(test)]
+#[path = "server_list/tests.rs"]
+mod tests;
diff --git a/launcher/src/server_list/tests.rs b/launcher/src/server_list/tests.rs
new file mode 100644
index 000000000..4bdfb57d6
--- /dev/null
+++ b/launcher/src/server_list/tests.rs
@@ -0,0 +1,143 @@
+use super::*;
+use std::path::PathBuf;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-servers-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+fn s(v: &str) -> Tag {
+    Tag::String(v.into())
+}
+
+/// A servers.dat as the game writes it: one shown server with a picture and the fields the
+/// launcher doesn't use, then one joined through Direct Connection.
+fn vanilla_file(home: &Path) -> Vec<u8> {
+    let png = [0x89, b'P', b'N', b'G', 1, 2, 3];
+    let icon = base64::engine::general_purpose::STANDARD.encode(png);
+    let root = NamedTag {
+        name: "".into(),
+        tag: Tag::compound([(
+            "servers",
+            Tag::List(vec![
+                Tag::compound([
+                    ("name", s("Friends")),
+                    ("ip", s("friends.example:25570")),
+                    ("icon", s(&icon)),
+                    ("acceptTextures", Tag::Byte(1)),
+                    ("acceptedCodeOfConduct", Tag::Int(-12345)),
+                    ("hidden", Tag::Byte(0)),
+                ]),
+                Tag::compound([
+                    ("name", s("Minecraft Server")),
+                    ("ip", s("direct.example")),
+                    ("hidden", Tag::Byte(1)),
+                ]),
+            ]),
+        )]),
+    };
+    let bytes = nbt::write_named(&root, Limits::default()).unwrap();
+    fs::write(home.join(FILE), &bytes).unwrap();
+    bytes
+}
+
+fn entries(home: &Path) -> Vec<Tag> {
+    let bytes = fs::read(home.join(FILE)).unwrap();
+    match nbt::read_named(&bytes, Limits::default())
+        .unwrap()
+        .0
+        .tag
+        .get("servers")
+    {
+        Some(Tag::List(list)) => list.clone(),
+        other => panic!("no servers list: {other:?}"),
+    }
+}
+
+#[test]
+fn reads_the_shown_servers_with_their_pictures() {
+    let home = scratch("reads");
+    vanilla_file(home.as_path());
+    let list = List::load(home.as_path());
+    assert_eq!(
+        list.servers(),
+        vec![Server {
+            name: "Friends".into(),
+            ip: "friends.example:25570".into(),
+            icon: Some(vec![0x89, b'P', b'N', b'G', 1, 2, 3]),
+        }]
+    );
+    // No file, or one that isn't NBT: an empty list, as in the game.
+    assert!(List::load(&home.as_path().join("none"))
+        .servers()
+        .is_empty());
+    fs::write(home.as_path().join(FILE), b"not nbt").unwrap();
+    assert!(List::load(home.as_path()).servers().is_empty());
+}
+
+#[test]
+fn adding_and_removing_keeps_every_other_field_and_the_hidden_servers() {
+    let home = scratch("keeps");
+    let original = vanilla_file(home.as_path());
+    let before = entries(home.as_path());
+
+    let mut list = List::load(home.as_path());
+    list.add("  Hub ", " hub.example ").unwrap();
+    assert!(list.add("x", "  ").is_err());
+    list.save(home.as_path()).unwrap();
+    // The game's own backup of what was there.
+    assert_eq!(
+        fs::read(home.as_path().join("servers.dat_old")).unwrap(),
+        original
+    );
+    assert!(!home.as_path().join("servers.dat_new").exists());
+
+    let after = entries(home.as_path());
+    assert_eq!(after.len(), 3);
+    assert_eq!(
+        after[0], before[0],
+        "the first server is written back untouched"
+    );
+    assert_eq!(
+        after[1],
+        Tag::compound([
+            ("name", s("Hub")),
+            ("ip", s("hub.example")),
+            ("hidden", Tag::Byte(0)),
+        ]),
+        "a new server goes after the shown ones, before the hidden ones"
+    );
+    assert_eq!(after[2], before[1], "the hidden server stays");
+
+    let mut list = List::load(home.as_path());
+    let (i, found) = find(&list, "friends").unwrap();
+    assert_eq!((i, found.ip.as_str()), (0, "friends.example:25570"));
+    assert_eq!(find(&list, "2").unwrap().1.name, "Hub");
+    assert_eq!(find(&list, "HUB.example").unwrap().0, 1);
+    assert!(find(&list, "3").is_err(), "the hidden one can't be named");
+    assert_eq!(list.remove(0).unwrap().name, "Friends");
+    assert!(list.remove(5).is_err());
+    list.save(home.as_path()).unwrap();
+    assert_eq!(
+        entries(home.as_path()),
+        vec![after[1].clone(), before[1].clone()]
+    );
+}
+
+#[test]
+fn a_server_without_a_name_gets_the_games_default() {
+    let home = scratch("default");
+    let mut list = List::load(home.as_path());
+    list.add("", "play.example").unwrap();
+    list.save(home.as_path()).unwrap();
+    assert!(!home.as_path().join("servers.dat_old").exists());
+    assert_eq!(
+        List::load(home.as_path()).servers()[0].name,
+        "Minecraft Server"
+    );
+}
diff --git a/launcher/src/servers_page.rs b/launcher/src/servers_page.rs
index 0a5618768..e3ed4f441 100644
--- a/launcher/src/servers_page.rs
+++ b/launcher/src/servers_page.rs
@@ -32,10 +32,24 @@ pub(super) enum Field {
     Port,
     Token,
     Email,
+    /// The instance dialog's (`instances_page.rs`).
+    InstanceName,
+    InstanceGroup,
+    /// Home's Multiplayer section's (`multiplayer_page.rs`).
+    ServerName,
+    ServerAddress,
+    /// Home's Console's search (`console_page.rs`).
+    ConsoleSearch,
+    /// The Launch panel's (`launch_page.rs`).
+    PreLaunch,
+    Wrapper,
+    LaunchEnv,
+    /// Settings' new offline name (`switch_page.rs`).
+    OfflineName,
 }
 
 impl Field {
-    const ALL: [Field; 9] = [
+    const ALL: [Field; 18] = [
         Field::Name,
         Field::Seed,
         Field::Players,
@@ -45,6 +59,15 @@ impl Field {
         Field::Port,
         Field::Token,
         Field::Email,
+        Field::InstanceName,
+        Field::InstanceGroup,
+        Field::ServerName,
+        Field::ServerAddress,
+        Field::ConsoleSearch,
+        Field::PreLaunch,
+        Field::Wrapper,
+        Field::LaunchEnv,
+        Field::OfflineName,
     ];
 }
 
@@ -163,7 +186,7 @@ pub(super) struct Servers {
     focus: HashMap<Field, FocusHandle>,
     focused: Option<Field>,
     /// The field to put the keyboard in on the next frame.
-    focus_soon: Option<Field>,
+    pub(super) focus_soon: Option<Field>,
     /// A suggested value shown selected: the first key typed replaces it.
     selected: Option<Field>,
     /// A field whose value was refused, and why: shown under it until it's edited.
@@ -961,11 +984,15 @@ impl Launcher {
                     command,
                 );
                 match typed {
+                    Key::Enter if matches!(f, Field::InstanceName | Field::InstanceGroup) => {
+                        this.save_instance(cx)
+                    }
                     Key::Enter => this.field_enter(f),
                     Key::Escape => {
                         if this.servers.create.is_some() && !this.servers.creating {
                             this.servers.create = None;
                         }
+                        this.instance_escape();
                         window.blur();
                     }
                     Key::Paste => {
@@ -1017,6 +1044,10 @@ impl Launcher {
             Field::Port => self.save_port(),
             Field::Token => self.save_token(),
             Field::Email => self.invite_friend(),
+            Field::InstanceName | Field::InstanceGroup | Field::ConsoleSearch => {}
+            Field::PreLaunch | Field::Wrapper | Field::LaunchEnv => self.save_launch(),
+            Field::OfflineName => self.offline_name_enter(),
+            Field::ServerName | Field::ServerAddress => self.add_server(),
         }
     }
 
@@ -1627,7 +1658,7 @@ impl Launcher {
                         )
                         .bg(t.plate)
                         .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
-                            cx.write_to_clipboard(gpui::ClipboardItem::new_string(
+                            copy_to_clipboard(cx, gpui::ClipboardItem::new_string(
                                 copy_text.clone(),
                             ));
                             this.servers.copied = Some(Instant::now());
diff --git a/launcher/src/shortcut.rs b/launcher/src/shortcut.rs
new file mode 100644
index 000000000..b4e97abd4
--- /dev/null
+++ b/launcher/src/shortcut.rs
@@ -0,0 +1,427 @@
+//! A shortcut on the desktop that plays one instance: it runs
+//! `horizon-launcher play --instance <id>`, so the game starts without the launcher's window.
+//!
+//! - Linux: `<name> (Horizon).desktop` on the desktop (executable, and marked trusted with `gio`
+//!   where it exists, so GNOME starts it), and the same entry in the applications menu
+//!   (`applications/horizon-instance-<id>.desktop`, `desktop::data_home`).
+//! - macOS: `<name> (Horizon).app`, a small app whose program is a shell script, with Horizon's
+//!   icon. It has no Dock icon of its own (`LSUIElement`): the game's window is the one to see.
+//! - Windows: `<name> (Horizon).lnk`, a Shell Link as Microsoft's published [MS-SHLLINK] format
+//!   lays it out, to the launcher's `.exe` with Horizon's icon.
+//!
+//! Each shortcut names its instance's id inside it, so removing finds it after a rename.
+//! `HORIZON_LAUNCHER_DESKTOP` points the desktop folder elsewhere, for tests.
+//!
+//! [MS-SHLLINK]: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-shllink/
+use crate::desktop;
+use crate::desktop_seams;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+pub const DESKTOP_ENV: &str = "HORIZON_LAUNCHER_DESKTOP";
+const MAC_ICON: &[u8] = include_bytes!("../../packaging/icons/horizon.icns");
+/// The key a Linux shortcut names its instance with.
+const INSTANCE_KEY: &str = "X-Horizon-Instance";
+/// And a macOS one, in its Info.plist.
+const MAC_KEY: &str = "<key>HorizonInstance</key>";
+
+/// The kinds of shortcut, one per system: all of them can be written and tested anywhere.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum System {
+    Linux,
+    Mac,
+    Windows,
+}
+
+impl System {
+    pub fn here() -> Self {
+        if cfg!(target_os = "macos") {
+            Self::Mac
+        } else if cfg!(windows) {
+            Self::Windows
+        } else {
+            Self::Linux
+        }
+    }
+
+    fn extension(self) -> &'static str {
+        match self {
+            Self::Linux => "desktop",
+            Self::Mac => "app",
+            Self::Windows => "lnk",
+        }
+    }
+}
+
+/// The desktop folder: `HORIZON_LAUNCHER_DESKTOP`, else the system's.
+pub fn desktop_dir() -> Option<PathBuf> {
+    std::env::var_os(DESKTOP_ENV)
+        .filter(|v| !v.is_empty())
+        .map(PathBuf::from)
+        .or_else(dirs::desktop_dir)
+}
+
+/// The shortcut's file name: the instance's name without the characters a file name can't
+/// hold on any of the three systems.
+pub fn file_name(name: &str, system: System) -> String {
+    let clean: String = name
+        .chars()
+        .map(|c| match c {
+            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '-',
+            c if c.is_control() => '-',
+            c => c,
+        })
+        .collect();
+    let clean = clean.trim().trim_matches('.');
+    let clean = if clean.is_empty() { "Instance" } else { clean };
+    format!("{clean} (Horizon).{}", system.extension())
+}
+
+/// The id as a file name or bundle id part: letters, digits and `-`.
+fn slug(id: &str) -> String {
+    id.chars()
+        .map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })
+        .collect()
+}
+
+/// A Linux `.desktop` entry that plays the instance.
+pub fn desktop_entry(exe: &Path, id: &str, name: &str) -> String {
+    let field = |s: &str| s.replace(['\n', '\r'], " ");
+    format!(
+        "[Desktop Entry]\n\
+         Type=Application\n\
+         Name={name}\n\
+         Comment=Play {name} in Horizon\n\
+         Exec={} play --instance {}\n\
+         TryExec={}\n\
+         Icon=horizon\n\
+         Terminal=false\n\
+         Categories=Game;\n\
+         StartupWMClass=horizon\n\
+         {INSTANCE_KEY}={id}\n",
+        desktop::quote(exe),
+        desktop::quote(Path::new(id)),
+        exe.display(),
+        name = field(name),
+        id = field(id),
+    )
+}
+
+/// `'text'` for a POSIX shell.
+fn sh_quote(text: &str) -> String {
+    format!("'{}'", text.replace('\'', r"'\''"))
+}
+
+fn xml(text: &str) -> String {
+    text.replace('&', "&amp;")
+        .replace('<', "&lt;")
+        .replace('>', "&gt;")
+        .replace('"', "&quot;")
+}
+
+/// A macOS app's files, by path inside the `.app`, and whether each is a program.
+pub fn mac_app(exe: &Path, id: &str, name: &str) -> Vec<(&'static str, Vec<u8>, bool)> {
+    let plist = format!(
+        r#"<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleExecutable</key>
+	<string>play</string>
+	<key>CFBundleIdentifier</key>
+	<string>dev.horizon.instance.{}</string>
+	<key>CFBundleName</key>
+	<string>{}</string>
+	<key>CFBundleIconFile</key>
+	<string>horizon</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>LSUIElement</key>
+	<true/>
+	{MAC_KEY}
+	<string>{}</string>
+</dict>
+</plist>
+"#,
+        slug(id),
+        xml(name),
+        xml(id),
+    );
+    let script = format!(
+        "#!/bin/sh\n# Plays the Horizon instance {}.\nexec {} play --instance {}\n",
+        name.replace('\n', " "),
+        sh_quote(&exe.to_string_lossy()),
+        sh_quote(id),
+    );
+    vec![
+        ("Contents/Info.plist", plist.into_bytes(), false),
+        ("Contents/MacOS/play", script.into_bytes(), true),
+        ("Contents/Resources/horizon.icns", MAC_ICON.to_vec(), false),
+    ]
+}
+
+/// The arguments of a Windows shortcut: the id in quotes, with its own quotes escaped.
+fn windows_args(id: &str) -> String {
+    format!("play --instance \"{}\"", id.replace('"', "\\\""))
+}
+
+fn utf16(text: &str) -> Vec<u8> {
+    text.encode_utf16().flat_map(u16::to_le_bytes).collect()
+}
+
+/// A Windows Shell Link ([MS-SHLLINK]) to `exe` (a Windows path) with `args`: the header, a
+/// LinkInfo with the local path (ANSI and Unicode), then the name, working folder, arguments and
+/// icon as Unicode strings.
+pub fn lnk(exe: &str, args: &str, comment: &str) -> Vec<u8> {
+    const HAS_LINK_INFO: u32 = 0x02;
+    const HAS_NAME: u32 = 0x04;
+    const HAS_WORKING_DIR: u32 = 0x10;
+    const HAS_ARGUMENTS: u32 = 0x20;
+    const HAS_ICON_LOCATION: u32 = 0x40;
+    const IS_UNICODE: u32 = 0x80;
+    const FILE_ATTRIBUTE_NORMAL: u32 = 0x80;
+    const SW_SHOWNORMAL: u32 = 1;
+    let flags =
+        HAS_LINK_INFO | HAS_NAME | HAS_WORKING_DIR | HAS_ARGUMENTS | HAS_ICON_LOCATION | IS_UNICODE;
+    let mut out = Vec::new();
+    out.extend(0x4Cu32.to_le_bytes());
+    // CLSID 00021401-0000-0000-C000-000000000046.
+    out.extend([
+        0x01, 0x14, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x46,
+    ]);
+    out.extend(flags.to_le_bytes());
+    out.extend(FILE_ATTRIBUTE_NORMAL.to_le_bytes());
+    out.extend([0; 24]); // creation, access and write times: unknown
+    out.extend(0u32.to_le_bytes()); // file size
+    out.extend(0i32.to_le_bytes()); // icon index
+    out.extend(SW_SHOWNORMAL.to_le_bytes());
+    out.extend([0; 2 + 2 + 4 + 4]); // hot key, reserved
+
+    // LinkInfo: a header with the Unicode offsets (0x24 bytes), a VolumeID for a fixed drive
+    // with no label, the path in ANSI (anything else as '?') and in UTF-16, and empty suffixes.
+    let header = 0x24u32;
+    let volume: Vec<u8> = [0x11u32, 3, 0, 0x10]
+        .iter()
+        .flat_map(|v| v.to_le_bytes())
+        .chain([0])
+        .collect();
+    let ansi: Vec<u8> = exe
+        .chars()
+        .map(|c| if c.is_ascii() { c as u8 } else { b'?' })
+        .chain([0])
+        .collect();
+    let wide: Vec<u8> = utf16(exe).into_iter().chain([0, 0]).collect();
+    let volume_at = header;
+    let path_at = volume_at + volume.len() as u32;
+    let suffix_at = path_at + ansi.len() as u32;
+    let wide_at = suffix_at + 1;
+    let wide_suffix_at = wide_at + wide.len() as u32;
+    let size = wide_suffix_at + 2;
+    for v in [
+        size,
+        header,
+        1, // VolumeIDAndLocalBasePath
+        volume_at,
+        path_at,
+        0, // no network path
+        suffix_at,
+        wide_at,
+        wide_suffix_at,
+    ] {
+        out.extend(v.to_le_bytes());
+    }
+    out.extend(volume);
+    out.extend(ansi);
+    out.push(0);
+    out.extend(wide);
+    out.extend([0, 0]);
+
+    let folder = exe.rsplit_once('\\').map_or("", |(dir, _)| dir);
+    for text in [comment, folder, args, exe] {
+        out.extend((text.encode_utf16().count() as u16).to_le_bytes());
+        out.extend(utf16(text));
+    }
+    out.extend(0u32.to_le_bytes()); // no extra data
+    out
+}
+
+/// Whether the shortcut at `path` plays the instance `id`.
+fn plays(path: &Path, id: &str) -> bool {
+    let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
+    match ext {
+        "desktop" => fs::read_to_string(path)
+            .is_ok_and(|t| t.lines().any(|l| l == format!("{INSTANCE_KEY}={id}"))),
+        "app" => fs::read_to_string(path.join("Contents/Info.plist"))
+            .is_ok_and(|t| t.contains(&format!("{MAC_KEY}\n\t<string>{}</string>", xml(id)))),
+        "lnk" => fs::read(path).is_ok_and(|b| {
+            let want = utf16(&windows_args(id));
+            b.windows(want.len()).any(|w| w == want)
+        }),
+        _ => false,
+    }
+}
+
+/// Writes `bytes` beside `path` and renames it in, so nothing reads half a file.
+fn write(path: &Path, bytes: &[u8], program: bool) -> Result<(), String> {
+    let fail = |e: std::io::Error| format!("{}: {e}", path.display());
+    if let Some(dir) = path.parent() {
+        fs::create_dir_all(dir).map_err(fail)?;
+    }
+    let temp = path.with_extension("horizon-tmp");
+    fs::write(&temp, bytes).map_err(fail)?;
+    #[cfg(unix)]
+    if program {
+        use std::os::unix::fs::PermissionsExt;
+        fs::set_permissions(&temp, fs::Permissions::from_mode(0o755)).map_err(fail)?;
+    }
+    #[cfg(not(unix))]
+    let _ = program;
+    fs::rename(&temp, path).map_err(fail)
+}
+
+/// Moves a file or folder out of the way, where the player can get it back.
+pub type Trash<'a> = &'a dyn Fn(&Path) -> Result<(), String>;
+
+/// Makes the shortcut for `system` in `desktop` (and, for Linux, the menu entry under
+/// `menu`, an `applications` folder). The instance's shortcut of the same name is rewritten;
+/// one under an older name goes to `trash`. Returns what it wrote.
+pub fn make_in(
+    system: System,
+    desktop: &Path,
+    menu: Option<&Path>,
+    exe: &Path,
+    id: &str,
+    name: &str,
+    trash: Trash,
+) -> Result<Vec<PathBuf>, String> {
+    let path = desktop.join(file_name(name, system));
+    let item = menu.map(|m| m.join(format!("horizon-instance-{}.desktop", slug(id))));
+    for old in find_in(desktop, menu, id) {
+        if old != path && Some(&old) != item.as_ref() {
+            trash(&old)?;
+        }
+    }
+    if path.exists() && !plays(&path, id) {
+        return Err(format!(
+            "{} is already on the desktop, and isn't this instance's shortcut.",
+            path.file_name().unwrap().to_string_lossy()
+        ));
+    }
+    let mut made = vec![path.clone()];
+    match system {
+        System::Linux => {
+            let entry = desktop_entry(exe, id, name);
+            write(&path, entry.as_bytes(), true)?;
+            if let Some(item) = item {
+                write(&item, entry.as_bytes(), false)?;
+                made.push(item);
+            }
+        }
+        System::Mac => {
+            for (inside, bytes, program) in mac_app(exe, id, name) {
+                write(&path.join(inside), &bytes, program)?;
+            }
+        }
+        System::Windows => write(
+            &path,
+            &lnk(
+                &exe.to_string_lossy(),
+                &windows_args(id),
+                &format!("Play {name} in Horizon"),
+            ),
+            false,
+        )?,
+    }
+    Ok(made)
+}
+
+/// The instance's shortcuts in `desktop` and the menu.
+pub fn find_in(desktop: &Path, menu: Option<&Path>, id: &str) -> Vec<PathBuf> {
+    let mut found: Vec<PathBuf> = fs::read_dir(desktop)
+        .into_iter()
+        .flatten()
+        .flatten()
+        .map(|e| e.path())
+        .filter(|p| plays(p, id))
+        .collect();
+    if let Some(item) = menu
+        .map(|m| m.join(format!("horizon-instance-{}.desktop", slug(id))))
+        .filter(|p| plays(p, id))
+    {
+        found.push(item);
+    }
+    found.sort();
+    found
+}
+
+/// Moves the instance's shortcuts to `trash`. Returns what it moved.
+pub fn remove_in(
+    desktop: &Path,
+    menu: Option<&Path>,
+    id: &str,
+    trash: Trash,
+) -> Result<Vec<PathBuf>, String> {
+    let found = find_in(desktop, menu, id);
+    for path in &found {
+        trash(path)?;
+    }
+    Ok(found)
+}
+
+fn menu() -> Option<PathBuf> {
+    (System::here() == System::Linux)
+        .then(desktop::data_home)
+        .flatten()
+        .map(|d| d.join("applications"))
+}
+
+fn desktop_or_err() -> Result<PathBuf, String> {
+    desktop_dir().ok_or_else(|| "This computer has no desktop folder.".into())
+}
+
+/// Makes the shortcut on this computer's desktop that plays `id`, starting `exe`.
+pub fn make(exe: &Path, id: &str, name: &str) -> Result<Vec<PathBuf>, String> {
+    let desktop = desktop_or_err()?;
+    let made = make_in(
+        System::here(),
+        &desktop,
+        menu().as_deref(),
+        &desktop::target(exe),
+        id,
+        name,
+        &desktop_seams::to_trash,
+    )?;
+    if System::here() == System::Linux {
+        // GNOME starts a desktop file only once it is trusted; elsewhere this does nothing.
+        let _ = std::process::Command::new("gio")
+            .args(["set", "-t", "string"])
+            .arg(&made[0])
+            .args(["metadata::trusted", "true"])
+            .stdout(std::process::Stdio::null())
+            .stderr(std::process::Stdio::null())
+            .status();
+    }
+    Ok(made)
+}
+
+/// The instance's shortcuts on this computer.
+pub fn find(id: &str) -> Vec<PathBuf> {
+    desktop_dir()
+        .map(|d| find_in(&d, menu().as_deref(), id))
+        .unwrap_or_default()
+}
+
+/// Moves the instance's shortcuts on this computer to the trash.
+pub fn remove(id: &str) -> Result<Vec<PathBuf>, String> {
+    remove_in(
+        &desktop_or_err()?,
+        menu().as_deref(),
+        id,
+        &desktop_seams::to_trash,
+    )
+}
+
+#[cfg(test)]
+#[path = "shortcut/tests.rs"]
+mod tests;
diff --git a/launcher/src/shortcut/tests.rs b/launcher/src/shortcut/tests.rs
new file mode 100644
index 000000000..ce49d5b20
--- /dev/null
+++ b/launcher/src/shortcut/tests.rs
@@ -0,0 +1,197 @@
+use super::*;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!("horizon-shortcut-{name}-{}", std::process::id()));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+#[test]
+fn names_fit_every_system() {
+    assert_eq!(
+        file_name("Hardcore", System::Linux),
+        "Hardcore (Horizon).desktop"
+    );
+    assert_eq!(
+        file_name("A/B: C?", System::Windows),
+        "A-B- C- (Horizon).lnk"
+    );
+    assert_eq!(file_name(" .. ", System::Mac), "Instance (Horizon).app");
+    assert_eq!(slug("port:all the mods"), "port-all-the-mods");
+}
+
+#[test]
+fn a_linux_entry_plays_its_instance() {
+    let entry = desktop_entry(
+        Path::new("/opt/My Horizon/horizon-launcher"),
+        "port:atm",
+        "ATM",
+    );
+    assert!(entry.starts_with("[Desktop Entry]\nType=Application\nName=ATM\n"));
+    assert!(entry
+        .contains("\nExec=\"/opt/My Horizon/horizon-launcher\" play --instance \"port:atm\"\n"));
+    assert!(entry.contains("\nTryExec=/opt/My Horizon/horizon-launcher\n"));
+    assert!(entry.ends_with("\nX-Horizon-Instance=port:atm\n"));
+    let odd = desktop_entry(Path::new("/x"), "a", "Two\nlines");
+    assert!(odd.contains("Name=Two lines\n"));
+}
+
+#[test]
+fn a_mac_app_runs_a_script_that_plays_its_instance() {
+    let files = mac_app(
+        Path::new("/Applications/Horizon Launcher.app/Contents/MacOS/horizon-launcher"),
+        "it's",
+        "Tom & Jerry",
+    );
+    let (_, plist, _) = &files[0];
+    let plist = String::from_utf8(plist.clone()).unwrap();
+    assert!(plist.contains("<string>Tom &amp; Jerry</string>"));
+    assert!(plist.contains("<string>dev.horizon.instance.it-s</string>"));
+    assert!(plist.contains("<key>LSUIElement</key>\n\t<true/>"));
+    let (path, script, program) = &files[1];
+    assert_eq!((*path, *program), ("Contents/MacOS/play", true));
+    assert!(String::from_utf8(script.clone()).unwrap().ends_with(
+        "exec '/Applications/Horizon Launcher.app/Contents/MacOS/horizon-launcher' play \
+         --instance 'it'\\''s'\n"
+    ));
+    assert_eq!(files[2].1, MAC_ICON);
+}
+
+/// Reads a Shell Link back by its spec: the header, the LinkInfo's paths, and the strings.
+fn read_lnk(b: &[u8]) -> (u32, String, String, Vec<String>) {
+    let u32_at = |at: usize| u32::from_le_bytes(b[at..at + 4].try_into().unwrap());
+    assert_eq!(u32_at(0), 0x4C);
+    assert_eq!(
+        &b[4..20],
+        &[1, 0x14, 2, 0, 0, 0, 0, 0, 0xC0, 0, 0, 0, 0, 0, 0, 0x46]
+    );
+    let flags = u32_at(20);
+    assert_eq!(u32_at(60), 1, "show normal");
+    let info = 76;
+    let size = u32_at(info) as usize;
+    assert_eq!(u32_at(info + 4), 0x24);
+    assert_eq!(u32_at(info + 8), 1);
+    let volume = info + u32_at(info + 12) as usize;
+    assert_eq!((u32_at(volume), u32_at(volume + 4)), (0x11, 3));
+    let cstr = |at: usize| {
+        let end = b[at..].iter().position(|&c| c == 0).unwrap();
+        String::from_utf8(b[at..at + end].to_vec()).unwrap()
+    };
+    let ansi = cstr(info + u32_at(info + 16) as usize);
+    assert_eq!(cstr(info + u32_at(info + 24) as usize), "");
+    let wide_at = info + u32_at(info + 28) as usize;
+    let wide: Vec<u16> = b[wide_at..]
+        .chunks(2)
+        .map(|c| u16::from_le_bytes([c[0], c[1]]))
+        .take_while(|&c| c != 0)
+        .collect();
+    let wide = String::from_utf16(&wide).unwrap();
+    assert_eq!(
+        ansi.replace('?', ""),
+        wide.replace(|c: char| !c.is_ascii(), "")
+    );
+    let mut at = info + size;
+    let mut strings = Vec::new();
+    for _ in 0..4 {
+        let n = u16::from_le_bytes([b[at], b[at + 1]]) as usize;
+        let units: Vec<u16> = b[at + 2..at + 2 + 2 * n]
+            .chunks(2)
+            .map(|c| u16::from_le_bytes([c[0], c[1]]))
+            .collect();
+        strings.push(String::from_utf16(&units).unwrap());
+        at += 2 + 2 * n;
+    }
+    assert_eq!(&b[at..], &[0, 0, 0, 0], "the terminal block ends it");
+    (flags, ansi, wide, strings)
+}
+
+#[test]
+fn a_windows_shortcut_is_a_shell_link_to_the_launcher() {
+    let exe = r"C:\Users\Zoé\AppData\Local\Horizon\horizon-launcher.exe";
+    let b = lnk(exe, &windows_args("port:atm"), "Play ATM in Horizon");
+    let (flags, ansi, wide, strings) = read_lnk(&b);
+    assert_eq!(flags, 0x02 | 0x04 | 0x10 | 0x20 | 0x40 | 0x80);
+    assert_eq!(
+        ansi,
+        r"C:\Users\Zo?\AppData\Local\Horizon\horizon-launcher.exe"
+    );
+    assert_eq!(wide, exe);
+    assert_eq!(
+        strings,
+        [
+            "Play ATM in Horizon",
+            r"C:\Users\Zoé\AppData\Local\Horizon",
+            "play --instance \"port:atm\"",
+            exe,
+        ]
+    );
+}
+
+#[test]
+fn shortcuts_are_made_found_renamed_and_removed() {
+    let root = scratch("make");
+    let (desktop, menu, trash) = (
+        root.join("Desktop"),
+        root.join("applications"),
+        root.join("trash"),
+    );
+    let bin = trash.clone();
+    let trash_fn = move |p: &Path| desktop_seams::to_folder(p, &bin);
+    let t: Trash = &trash_fn;
+    let exe = Path::new("/opt/horizon-launcher");
+    for system in [System::Linux, System::Mac, System::Windows] {
+        let made = make_in(
+            system,
+            &desktop,
+            Some(&menu),
+            exe,
+            "hardcore",
+            "Hardcore",
+            t,
+        )
+        .unwrap();
+        assert_eq!(made[0], desktop.join(file_name("Hardcore", system)));
+        assert_eq!(find_in(&desktop, Some(&menu), "hardcore"), {
+            let mut m = made.clone();
+            m.sort();
+            m
+        });
+        // Again: rewritten in place, nothing in the trash.
+        make_in(
+            system,
+            &desktop,
+            Some(&menu),
+            exe,
+            "hardcore",
+            "Hardcore",
+            t,
+        )
+        .unwrap();
+        assert!(!trash.exists());
+        // Renamed: the old one goes, the new one is there.
+        let made = make_in(system, &desktop, Some(&menu), exe, "hardcore", "Hard", t).unwrap();
+        assert!(made[0].ends_with(file_name("Hard", system)));
+        assert!(!desktop.join(file_name("Hardcore", system)).exists());
+        assert!(find_in(&desktop, Some(&menu), "skyblock").is_empty());
+        let gone = remove_in(&desktop, Some(&menu), "hardcore", t).unwrap();
+        assert_eq!(gone.len(), made.len());
+        assert!(find_in(&desktop, Some(&menu), "hardcore").is_empty());
+        fs::remove_dir_all(&trash).unwrap();
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let made = make_in(System::Mac, &desktop, None, exe, "a", "A", t).unwrap();
+        let mode = fs::metadata(made[0].join("Contents/MacOS/play"))
+            .unwrap()
+            .permissions()
+            .mode();
+        assert_eq!(mode & 0o111, 0o111);
+    }
+    // Someone else's file of that name stays.
+    fs::write(desktop.join("Mine (Horizon).desktop"), "not ours").unwrap();
+    let err = make_in(System::Linux, &desktop, None, exe, "mine", "Mine", t).unwrap_err();
+    assert!(err.contains("isn't this instance's shortcut"), "{err}");
+    fs::remove_dir_all(&root).unwrap();
+}
diff --git a/launcher/src/shortcut_page.rs b/launcher/src/shortcut_page.rs
new file mode 100644
index 000000000..68eb9ca2d
--- /dev/null
+++ b/launcher/src/shortcut_page.rs
@@ -0,0 +1,69 @@
+//! The Instance row's desktop shortcut (`horizon_launcher::shortcut`): make one that plays the
+//! selected instance, or take it away.
+use super::*;
+use horizon_launcher::shortcut;
+
+#[derive(Default)]
+pub(super) struct Shortcuts {
+    /// The instance last looked at, and whether it has a shortcut: read again only when the
+    /// selection changes or a button is pressed, not on every frame.
+    seen: Option<(String, bool)>,
+    /// What the last press did, for that instance.
+    note: Option<(String, Result<String, String>)>,
+}
+
+impl Launcher {
+    fn has_shortcut(&mut self, id: &str) -> bool {
+        match &self.shortcuts.seen {
+            Some((seen, has)) if seen == id => *has,
+            _ => {
+                let has = !shortcut::find(id).is_empty();
+                self.shortcuts.seen = Some((id.to_string(), has));
+                has
+            }
+        }
+    }
+
+    fn toggle_shortcut(&mut self, id: String, name: String) {
+        let has = self.has_shortcut(&id);
+        let done = match has {
+            false => shortcut::make(backend::exe_path(), &id, &name).map(|made| {
+                let file = made[0].file_name().unwrap_or_default().to_string_lossy();
+                format!("{file} is on your desktop: it plays {name}.")
+            }),
+            true => shortcut::remove(&id).map(|_| format!("{name}'s shortcut is in the trash.")),
+        };
+        self.shortcuts.seen = None;
+        self.shortcuts.note = Some((id, done));
+    }
+
+    /// The row's button.
+    pub(super) fn shortcut_button(
+        &mut self,
+        instance: &instances::Instance,
+        cx: &mut Context<Self>,
+    ) -> Stateful<Div> {
+        let t = self.theme;
+        let label = match self.has_shortcut(&instance.id) {
+            true => "Remove shortcut",
+            false => "Shortcut",
+        };
+        let (id, name) = (instance.id.clone(), instance.name.clone());
+        button("instance-shortcut", label, Kind::Ghost, &t).on_click(cx.listener(
+            move |this, _: &ClickEvent, _, cx| {
+                this.toggle_shortcut(id.clone(), name.clone());
+                cx.notify();
+            },
+        ))
+    }
+
+    /// What the last press did, under the row, while that instance is selected.
+    pub(super) fn shortcut_note(&self, id: &str) -> Option<Div> {
+        let t = self.theme;
+        let (_, said) = self.shortcuts.note.as_ref().filter(|(n, _)| n == id)?;
+        Some(match said {
+            Ok(said) => text(theme::CAPTION).text_color(t.muted).child(said.clone()),
+            Err(e) => text(theme::CAPTION).text_color(t.danger).child(e.clone()),
+        })
+    }
+}
diff --git a/launcher/src/skin_page.rs b/launcher/src/skin_page.rs
new file mode 100644
index 000000000..5b2f6ae09
--- /dev/null
+++ b/launcher/src/skin_page.rs
@@ -0,0 +1,228 @@
+//! Settings > Account's skin panel for an offline name (`horizon_launcher::skins`): the front
+//! of the skin and the cape, choosing either from a PNG, and the model.
+use super::*;
+use gpui::RenderImage;
+use horizon_launcher::skins::{self, Model};
+use std::path::PathBuf;
+use std::sync::Arc;
+
+/// A baked preview, or None without one.
+type Preview = Option<Arc<RenderImage>>;
+
+#[derive(Default)]
+pub(super) struct SkinPanel {
+    /// The offline name it is for.
+    pub(super) name: String,
+    /// The two previews, baked at the window's scale (skin, cape), or None without one.
+    seen: Option<(f32, Preview, Preview)>,
+    /// What the last choice did, or why not.
+    note: Option<Result<String, String>>,
+}
+
+/// Points per skin texel in the preview.
+const TEXEL: f32 = 6.;
+
+impl Launcher {
+    pub(super) fn open_skin(&mut self, name: String) {
+        self.skin = match self.skin.take() {
+            Some(p) if p.name == name => None,
+            _ => Some(SkinPanel {
+                name,
+                ..SkinPanel::default()
+            }),
+        };
+    }
+
+    fn save_look(&mut self, change: impl FnOnce(&mut skins::Look)) -> Result<(), String> {
+        let Some(name) = self.skin.as_ref().map(|p| p.name.clone()) else {
+            return Ok(());
+        };
+        let mut accounts = Accounts::load();
+        let mut look = accounts.look(&name);
+        change(&mut look);
+        accounts.looks.insert(name.to_ascii_lowercase(), look);
+        accounts.save()?;
+        self.accounts = accounts;
+        if let Some(p) = &mut self.skin {
+            p.seen = None;
+        }
+        Ok(())
+    }
+
+    fn choose_look_file(&mut self, cape: bool, cx: &mut Context<Self>) {
+        let paths = cx.prompt_for_paths(PathPromptOptions {
+            files: true,
+            directories: false,
+            multiple: false,
+            prompt: Some("Choose".into()),
+        });
+        cx.spawn(async move |this, cx| {
+            let Ok(Ok(Some(mut paths))) = paths.await else {
+                return;
+            };
+            let Some(path) = paths.pop() else {
+                return;
+            };
+            let _ = this.update(cx, |this, cx| {
+                this.take_look_file(path, cape);
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    pub(super) fn take_look_file(&mut self, path: PathBuf, cape: bool) {
+        let Some(name) = self.skin.as_ref().map(|p| p.name.clone()) else {
+            return;
+        };
+        let done = skins::keep(&skins::dir(), &name, &path, cape).and_then(|()| {
+            self.save_look(|l| match cape {
+                false => l.skin = true,
+                true => l.cape = true,
+            })
+        });
+        if let Some(p) = &mut self.skin {
+            let said = match cape {
+                false => trf("{name}'s skin is kept.", &[("name", &name)]),
+                true => trf("{name}'s cape is kept.", &[("name", &name)]),
+            };
+            p.note = Some(done.map(|()| said));
+        }
+    }
+
+    fn previews(&mut self) -> (Preview, Preview) {
+        let scale = self.scale;
+        let Some(panel) = &mut self.skin else {
+            return (None, None);
+        };
+        if let Some((s, skin, cape)) = &panel.seen {
+            if *s == scale {
+                return (skin.clone(), cape.clone());
+            }
+        }
+        let look = self.accounts.look(&panel.name);
+        let (skin_file, cape_file) = skins::files(&skins::dir(), &panel.name);
+        let read = |f: &PathBuf| std::fs::read(f).ok();
+        let skin = read(&skin_file)
+            .filter(|_| look.skin)
+            .and_then(|b| skins::read_skin(&b).ok())
+            .map(|png| art::bake(&skins::front(&png, look.model), 16, 32, TEXEL, scale));
+        let cape = read(&cape_file)
+            .filter(|_| look.cape)
+            .and_then(|b| skins::read_cape(&b).ok())
+            .map(|png| art::bake(&skins::cape_front(&png), 10, 16, TEXEL, scale));
+        panel.seen = Some((scale, skin.clone(), cape.clone()));
+        (skin, cape)
+    }
+
+    /// The panel, under the offline names while open.
+    pub(super) fn skin_panel(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let name = self.skin.as_ref()?.name.clone();
+        if !self.accounts.offline.iter().any(|n| n == &name) {
+            self.skin = None;
+            return None;
+        }
+        let look = self.accounts.look(&name);
+        let (skin, cape) = self.previews();
+        let frame = |w: f32, h: f32, image: Preview, empty: &'static str| {
+            div()
+                .flex()
+                .items_center()
+                .justify_center()
+                .w(px(w + 24.))
+                .h(px(h + 24.))
+                .bg(t.well)
+                .border_2()
+                .border_color(t.outline)
+                .child(match image {
+                    Some(i) => gpui::img(i).w(px(w)).h(px(h)).into_any_element(),
+                    None => text(theme::CAPTION)
+                        .text_color(t.muted)
+                        .child(tr(empty))
+                        .into_any_element(),
+                })
+        };
+        let weak = cx.entity().downgrade();
+        let model = segments(
+            "skin-model",
+            &[(Model::Classic, "Classic arms"), (Model::Slim, "Slim arms")],
+            look.model,
+            &t,
+            move |m, _, cx| {
+                let _ = weak.update(cx, |this, cx| {
+                    let _ = this.save_look(|l| l.model = m);
+                    cx.notify();
+                });
+            },
+        );
+        let pick = |id: &'static str, label: &'static str, cape: bool, cx: &mut Context<Self>| {
+            button(id, label, Kind::Secondary, &t).on_click(cx.listener(
+                move |this, _: &ClickEvent, _, cx| {
+                    this.choose_look_file(cape, cx);
+                    cx.notify();
+                },
+            ))
+        };
+        let drop = |id: &'static str, label: &'static str, cape: bool, cx: &mut Context<Self>| {
+            button(id, label, Kind::Ghost, &t).on_click(cx.listener(
+                move |this, _: &ClickEvent, _, cx| {
+                    let _ = this.save_look(|l| match cape {
+                        false => l.skin = false,
+                        true => l.cape = false,
+                    });
+                    cx.notify();
+                },
+            ))
+        };
+        let mut skin_buttons =
+            div()
+                .flex()
+                .gap(px(6.))
+                .child(pick("skin-choose", "Choose a skin…", false, cx));
+        if look.skin {
+            skin_buttons = skin_buttons.child(drop("skin-remove", "Default skin", false, cx));
+        }
+        let mut cape_buttons =
+            div()
+                .flex()
+                .gap(px(6.))
+                .child(pick("cape-choose", "Choose a cape…", true, cx));
+        if look.cape {
+            cape_buttons = cape_buttons.child(drop("cape-remove", "No cape", true, cx));
+        }
+        let note = self.skin.as_ref().and_then(|p| p.note.clone());
+        Some(
+            plate(&t)
+                .flex()
+                .gap(px(20.))
+                .px(px(16.))
+                .py(px(14.))
+                .ml(px(40.))
+                .child(frame(16. * TEXEL, 32. * TEXEL, skin, "Default"))
+                .child(frame(10. * TEXEL, 16. * TEXEL, cape, "No cape"))
+                .child(
+                    div()
+                        .flex()
+                        .flex_col()
+                        .flex_1()
+                        .min_w_0()
+                        .gap(px(12.))
+                        .child(caps(trf("{name}'s skin", &[("name", &name)])).text_color(t.muted))
+                        .child(skin_buttons)
+                        .child(model)
+                        .child(cape_buttons)
+                        .children(note.map(|n| match n {
+                            Ok(said) => text(theme::CAPTION).text_color(t.muted).child(said),
+                            Err(e) => text(theme::CAPTION).text_color(t.danger).child(e),
+                        }))
+                        .child(text(theme::CAPTION).text_color(t.muted).child(tr(
+                            "A 64×64 (or 64×32) skin PNG and a 64×32 cape PNG, kept by the \
+                             launcher and given to the game when this name plays. The game \
+                             draws the default skins for now; it uses these once it can. A \
+                             Microsoft account's skin and cape: coming soon.",
+                        ))),
+                ),
+        )
+    }
+}
diff --git a/launcher/src/skins.rs b/launcher/src/skins.rs
new file mode 100644
index 000000000..c80cc9b90
--- /dev/null
+++ b/launcher/src/skins.rs
@@ -0,0 +1,176 @@
+//! Offline skins and capes: a PNG the player picks for an offline name, kept in the launcher's
+//! `skins/` folder, with its model (classic arms or slim). The game gets them in
+//! `HORIZON_OFFLINE_SKIN`, `HORIZON_OFFLINE_SKIN_MODEL` and `HORIZON_OFFLINE_CAPE` when that
+//! name plays; a game that doesn't read them yet draws the default skin, as before.
+//!
+//! Skins are the layout every Java Edition skin uses: 64×64, or the older 64×32 (whose left arm
+//! and leg are the right ones mirrored). Capes are 64×32 (or the older 22×17).
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+
+pub const SKIN_ENV: &str = "HORIZON_OFFLINE_SKIN";
+pub const MODEL_ENV: &str = "HORIZON_OFFLINE_SKIN_MODEL";
+pub const CAPE_ENV: &str = "HORIZON_OFFLINE_CAPE";
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Model {
+    /// Four-pixel arms ("Steve").
+    #[default]
+    Classic,
+    /// Three-pixel arms ("Alex").
+    Slim,
+}
+
+impl Model {
+    pub fn name(self) -> &'static str {
+        match self {
+            Model::Classic => "classic",
+            Model::Slim => "slim",
+        }
+    }
+}
+
+/// What an offline name wears.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Look {
+    #[serde(default)]
+    pub model: Model,
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub skin: bool,
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub cape: bool,
+}
+
+/// Where an offline name's files are: `skins/<name>.png` and `skins/<name>.cape.png`, the name
+/// in lowercase (offline names are kept once in any case).
+pub fn files(dir: &Path, name: &str) -> (PathBuf, PathBuf) {
+    let key = name.to_ascii_lowercase();
+    (
+        dir.join(format!("{key}.png")),
+        dir.join(format!("{key}.cape.png")),
+    )
+}
+
+pub fn dir() -> PathBuf {
+    crate::backend::data_dir().join("skins")
+}
+
+fn decode(bytes: &[u8]) -> Result<image::RgbaImage, String> {
+    image::load_from_memory_with_format(bytes, image::ImageFormat::Png)
+        .map(|i| i.to_rgba8())
+        .map_err(|_| "That isn't a PNG picture.".to_string())
+}
+
+/// A skin's picture, if it is one: 64×64 or 64×32.
+pub fn read_skin(bytes: &[u8]) -> Result<image::RgbaImage, String> {
+    let png = decode(bytes)?;
+    match png.dimensions() {
+        (64, 64) | (64, 32) => Ok(png),
+        (w, h) => Err(format!(
+            "A skin is 64×64 (or the older 64×32) pixels; this one is {w}×{h}."
+        )),
+    }
+}
+
+/// A cape's picture, if it is one: 64×32 or 22×17.
+pub fn read_cape(bytes: &[u8]) -> Result<image::RgbaImage, String> {
+    let png = decode(bytes)?;
+    match png.dimensions() {
+        (64, 32) | (22, 17) => Ok(png),
+        (w, h) => Err(format!(
+            "A cape is 64×32 (or the older 22×17) pixels; this one is {w}×{h}."
+        )),
+    }
+}
+
+/// A part of the skin copied to the front view: from (x, y), its size, to (x, y), mirrored.
+type Part = (u32, u32, u32, u32, u32, u32, bool);
+
+/// The front of the player, 16×32 texels: head, body, arms and legs, each with its outer layer
+/// over it (64×64 skins have one for every part; 64×32 only for the head).
+pub fn front(skin: &image::RgbaImage, model: Model) -> Vec<[u8; 4]> {
+    let w = 16usize;
+    let mut out = vec![[0u8; 4]; w * 32];
+    let modern = skin.height() == 64;
+    let arm = if model == Model::Slim { 3 } else { 4 };
+    let mut base: Vec<Part> = vec![
+        (8, 8, 8, 8, 4, 0, false),            // head
+        (20, 20, 8, 12, 4, 8, false),         // body
+        (44, 20, arm, 12, 4 - arm, 8, false), // right arm, on the viewer's left
+        (4, 20, 4, 12, 4, 20, false),         // right leg
+    ];
+    let mut outer: Vec<Part> = vec![(40, 8, 8, 8, 4, 0, false)];
+    if modern {
+        base.extend([
+            (36, 52, arm, 12, 12, 8, false),
+            (20, 52, 4, 12, 8, 20, false),
+        ]);
+        outer.extend([
+            (20, 36, 8, 12, 4, 8, false),
+            (44, 36, arm, 12, 4 - arm, 8, false),
+            (52, 52, arm, 12, 12, 8, false),
+            (4, 36, 4, 12, 4, 20, false),
+            (4, 52, 4, 12, 8, 20, false),
+        ]);
+    } else {
+        base.extend([(44, 20, arm, 12, 12, 8, true), (4, 20, 4, 12, 8, 20, true)]);
+    }
+    for (layer, parts) in [base, outer].into_iter().enumerate() {
+        for (fx, fy, pw, ph, tx, ty, mirrored) in parts {
+            for dy in 0..ph {
+                for dx in 0..pw {
+                    let sx = if mirrored { fx + pw - 1 - dx } else { fx + dx };
+                    let c = skin.get_pixel(sx, fy + dy).0;
+                    // The base layer is opaque in game; the outer one shows where it is drawn.
+                    if layer == 0 || c[3] > 0 {
+                        out[(ty + dy) as usize * w + (tx + dx) as usize] = [c[0], c[1], c[2], 255];
+                    }
+                }
+            }
+        }
+    }
+    out
+}
+
+/// The cape's outside, 10×16 texels.
+pub fn cape_front(cape: &image::RgbaImage) -> Vec<[u8; 4]> {
+    let mut out = Vec::with_capacity(160);
+    for y in 1..17 {
+        for x in 1..11 {
+            out.push(cape.get_pixel(x, y).0);
+        }
+    }
+    out
+}
+
+/// Keeps `file` as `name`'s skin (or cape), checked first.
+pub fn keep(dir: &Path, name: &str, file: &Path, cape: bool) -> Result<(), String> {
+    let bytes = std::fs::read(file).map_err(|e| format!("{}: {e}", file.display()))?;
+    match cape {
+        false => read_skin(&bytes).map(|_| ())?,
+        true => read_cape(&bytes).map(|_| ())?,
+    }
+    std::fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let (skin, cape_file) = files(dir, name);
+    let to = if cape { cape_file } else { skin };
+    std::fs::write(&to, bytes).map_err(|e| format!("{}: {e}", to.display()))
+}
+
+/// The variables the game gets for `name`'s look.
+pub fn env(dir: &Path, name: &str, look: &Look) -> Vec<(&'static str, String)> {
+    let (skin, cape) = files(dir, name);
+    let mut out = Vec::new();
+    if look.skin && skin.is_file() {
+        out.push((SKIN_ENV, skin.to_string_lossy().into_owned()));
+        out.push((MODEL_ENV, look.model.name().to_string()));
+    }
+    if look.cape && cape.is_file() {
+        out.push((CAPE_ENV, cape.to_string_lossy().into_owned()));
+    }
+    out
+}
+
+#[cfg(test)]
+#[path = "skins/tests.rs"]
+mod tests;
diff --git a/launcher/src/skins/tests.rs b/launcher/src/skins/tests.rs
new file mode 100644
index 000000000..6ce0473c5
--- /dev/null
+++ b/launcher/src/skins/tests.rs
@@ -0,0 +1,104 @@
+use super::*;
+
+/// A skin whose every texel says where it is: red = x, green = y.
+fn mapped(height: u32) -> image::RgbaImage {
+    image::RgbaImage::from_fn(64, height, |x, y| image::Rgba([x as u8, y as u8, 0, 255]))
+}
+
+fn png(img: &image::RgbaImage) -> Vec<u8> {
+    let mut out = std::io::Cursor::new(Vec::new());
+    img.write_to(&mut out, image::ImageFormat::Png).unwrap();
+    out.into_inner()
+}
+
+#[test]
+fn the_front_view_takes_each_part_from_its_place() {
+    let mut skin = mapped(64);
+    // No outer layer, except one hat texel.
+    for (x, y) in (0..64).flat_map(|x| (0..64).map(move |y| (x, y))) {
+        let outer = (40..48).contains(&x) && y < 16
+            || (16..56).contains(&x) && (32..48).contains(&y)
+            || (0..16).contains(&x) && (48..64).contains(&y)
+            || (48..64).contains(&x) && (48..64).contains(&y);
+        if outer {
+            skin.put_pixel(x, y, image::Rgba([0, 0, 0, 0]));
+        }
+    }
+    skin.put_pixel(41, 9, image::Rgba([200, 0, 9, 255]));
+    let f = front(&skin, Model::Classic);
+    let at = |x: usize, y: usize| f[y * 16 + x];
+    assert_eq!(at(4, 0), [8, 8, 0, 255], "head front starts at (8, 8)");
+    assert_eq!(at(5, 1), [200, 0, 9, 255], "the hat covers it");
+    assert_eq!(at(4, 8), [20, 20, 0, 255], "body");
+    assert_eq!(at(0, 8), [44, 20, 0, 255], "right arm");
+    assert_eq!(
+        at(12, 8),
+        [36, 52, 0, 255],
+        "left arm, its own on a 64×64 skin"
+    );
+    assert_eq!(at(8, 20), [20, 52, 0, 255], "left leg");
+    let slim = front(&skin, Model::Slim);
+    assert_eq!(slim[8 * 16], [0, 0, 0, 0], "slim arms leave a column");
+    assert_eq!(slim[8 * 16 + 1], [44, 20, 0, 255]);
+}
+
+#[test]
+fn an_old_skin_mirrors_its_right_limbs() {
+    let f = front(&mapped(32), Model::Classic);
+    let at = |x: usize, y: usize| f[y * 16 + x];
+    assert_eq!(
+        at(12, 8),
+        [47, 20, 0, 255],
+        "the left arm is the right one mirrored"
+    );
+    assert_eq!(at(15, 8), [44, 20, 0, 255]);
+    assert_eq!(at(8, 20), [7, 20, 0, 255]);
+}
+
+#[test]
+fn only_skin_and_cape_sizes_are_kept() {
+    assert!(read_skin(&png(&mapped(64))).is_ok());
+    assert!(read_skin(&png(&mapped(32))).is_ok());
+    let big = image::RgbaImage::new(128, 128);
+    assert_eq!(
+        read_skin(&png(&big)).unwrap_err(),
+        "A skin is 64×64 (or the older 64×32) pixels; this one is 128×128."
+    );
+    assert!(read_skin(b"not a png").unwrap_err().contains("isn't a PNG"));
+    assert!(read_cape(&png(&mapped(32))).is_ok());
+    assert!(read_cape(&png(&image::RgbaImage::new(22, 17))).is_ok());
+    assert!(read_cape(&png(&mapped(64))).is_err());
+    assert_eq!(cape_front(&mapped(32))[0], [1, 1, 0, 255]);
+}
+
+#[test]
+fn a_kept_look_reaches_the_game_only_with_its_files() {
+    let root = std::env::temp_dir().join(format!("horizon-skins-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&root);
+    std::fs::create_dir_all(&root).unwrap();
+    let (good, bad) = (root.join("alex.png"), root.join("big.png"));
+    std::fs::write(&good, png(&mapped(64))).unwrap();
+    std::fs::write(&bad, png(&image::RgbaImage::new(10, 10))).unwrap();
+    let dir = root.join("skins");
+    let look = Look {
+        model: Model::Slim,
+        skin: true,
+        cape: true,
+    };
+    assert!(env(&dir, "Alex", &look).is_empty(), "nothing kept yet");
+    keep(&dir, "Alex", &good, false).unwrap();
+    assert!(keep(&dir, "Alex", &bad, true).is_err());
+    let (skin, _) = files(&dir, "ALEX");
+    assert_eq!(
+        env(&dir, "alex", &look),
+        [
+            (SKIN_ENV, skin.to_string_lossy().into_owned()),
+            (MODEL_ENV, "slim".to_string())
+        ]
+    );
+    assert_eq!(
+        serde_json::to_string(&Look::default()).unwrap(),
+        r#"{"model":"classic"}"#
+    );
+    std::fs::remove_dir_all(&root).unwrap();
+}
diff --git a/launcher/src/switch_page.rs b/launcher/src/switch_page.rs
new file mode 100644
index 000000000..eb1e0bbfc
--- /dev/null
+++ b/launcher/src/switch_page.rs
@@ -0,0 +1,241 @@
+//! Who plays: the top bar's quick switch (a menu under the account chip) and Settings' offline
+//! names (`horizon_launcher::account::Accounts::offline`).
+use super::servers_page::Field;
+use super::*;
+use horizon_launcher::account::Player;
+
+impl Launcher {
+    /// The chip's two lines: the name that plays, and how.
+    pub(super) fn who_plays(&self) -> (String, &'static str) {
+        match self.accounts.player() {
+            Player::Microsoft(_) => (
+                self.accounts
+                    .selected()
+                    .map_or_else(String::new, |a| a.name.clone()),
+                tr("Microsoft account"),
+            ),
+            Player::Offline(name) => (name, tr("Offline")),
+            Player::GameName => (
+                self.offline_name.clone().unwrap_or_else(|| "Player".into()),
+                tr("Offline"),
+            ),
+        }
+    }
+
+    pub(super) fn play_as(&mut self, who: Player) {
+        let mut accounts = Accounts::load();
+        let done = accounts.play_as(who).and_then(|()| accounts.save());
+        match done {
+            Ok(()) => self.accounts = accounts,
+            Err(e) => self.sign_in_state = Some(SignInState::Done(Err(e))),
+        }
+        self.account_menu = false;
+    }
+
+    /// Everyone the player can play as, with how each signs in.
+    fn players(&self) -> Vec<(Player, String, &'static str)> {
+        let mut out: Vec<_> = self
+            .accounts
+            .accounts
+            .iter()
+            .map(|a| {
+                (
+                    Player::Microsoft(a.uuid.clone()),
+                    a.name.clone(),
+                    tr("Microsoft"),
+                )
+            })
+            .collect();
+        out.extend(
+            self.accounts
+                .offline
+                .iter()
+                .map(|n| (Player::Offline(n.clone()), n.clone(), tr("Offline"))),
+        );
+        out.push((
+            Player::GameName,
+            self.offline_name.clone().unwrap_or_else(|| "Player".into()),
+            tr("Offline, the game's name"),
+        ));
+        out
+    }
+
+    /// The menu under the account chip, while open.
+    pub(super) fn account_menu(&self, cx: &mut Context<Self>) -> Option<impl IntoElement> {
+        if !self.account_menu {
+            return None;
+        }
+        let t = self.theme;
+        let now = self.accounts.player();
+        let mut menu = div()
+            .id("account-menu")
+            .absolute()
+            .top(px(46.))
+            .right_0()
+            .w(px(280.))
+            .p(px(6.))
+            .border_2()
+            .border_color(t.outline)
+            .bg(t.surface)
+            .flex()
+            .flex_col()
+            .occlude();
+        for (i, (who, name, how)) in self.players().into_iter().enumerate() {
+            let chosen = who == now;
+            menu = menu.child(
+                div()
+                    .id(SharedString::from(format!("account-pick-{i}")))
+                    .flex()
+                    .items_center()
+                    .justify_between()
+                    .gap(px(8.))
+                    .h(px(46.))
+                    .px(px(10.))
+                    .rounded(px(theme::RADIUS))
+                    .cursor_pointer()
+                    .hover(move |s| s.bg(t.plate_soft))
+                    .child(
+                        div()
+                            .flex()
+                            .flex_col()
+                            .min_w_0()
+                            .child(text(theme::LABEL).truncate().text_color(t.ink).child(name))
+                            .child(text(theme::CAPTION).text_color(t.muted).child(how)),
+                    )
+                    .when(chosen, |d| {
+                        d.child(div().size(px(6.)).rounded_full().bg(t.accent))
+                    })
+                    .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        this.play_as(who.clone());
+                        cx.notify();
+                    })),
+            );
+        }
+        menu = menu.child(div().my(px(6.)).h(px(1.)).bg(t.rule)).child(
+            div()
+                .id("account-manage")
+                .flex()
+                .items_center()
+                .h(px(32.))
+                .px(px(10.))
+                .rounded(px(theme::RADIUS))
+                .text_size(px(theme::LABEL.px))
+                .text_color(t.muted)
+                .cursor_pointer()
+                .hover(move |s| s.bg(t.plate_soft).text_color(t.ink))
+                .child(tr("Manage accounts"))
+                .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                    this.account_menu = false;
+                    this.go(Page::Settings);
+                    cx.notify();
+                })),
+        );
+        Some(gpui::deferred(menu).with_priority(1))
+    }
+
+    fn add_offline_name(&mut self) {
+        let name = self.servers.value(Field::OfflineName).trim().to_string();
+        if name.is_empty() {
+            return;
+        }
+        self.play_as(Player::Offline(name));
+        if !matches!(self.sign_in_state, Some(SignInState::Done(Err(_)))) {
+            self.servers.text(Field::OfflineName).clear();
+        }
+    }
+
+    /// Enter in the offline name field.
+    pub(super) fn offline_name_enter(&mut self) {
+        self.add_offline_name();
+    }
+
+    /// Settings' rows for the offline names, after the Microsoft accounts: each with Play as
+    /// and Forget, then a field to add one.
+    pub(super) fn offline_rows(&mut self, mut n: usize, cx: &mut Context<Self>) -> (Div, usize) {
+        let t = self.theme;
+        let mut rows = div().flex().flex_col();
+        let now = self.accounts.player();
+        for (i, name) in self.accounts.offline.clone().into_iter().enumerate() {
+            let plays = now == Player::Offline(name.clone());
+            let mut actions = div().flex().gap(px(4.));
+            if !plays {
+                let who = Player::Offline(name.clone());
+                actions = actions.child(
+                    button(format!("offline-play-{i}"), "Play as", Kind::Secondary, &t).on_click(
+                        cx.listener(move |this, _: &ClickEvent, _, cx| {
+                            this.play_as(who.clone());
+                            cx.notify();
+                        }),
+                    ),
+                );
+            }
+            let dressed = name.clone();
+            actions = actions.child(
+                button(format!("offline-skin-{i}"), "Skin…", Kind::Ghost, &t).on_click(
+                    cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        this.open_skin(dressed.clone());
+                        cx.notify();
+                    }),
+                ),
+            );
+            let forget = name.clone();
+            actions = actions.child(
+                button(format!("offline-forget-{i}"), "Forget", Kind::Ghost, &t).on_click(
+                    cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        let mut accounts = Accounts::load();
+                        if accounts.remove_offline(&forget).is_ok() && accounts.save().is_ok() {
+                            this.accounts = accounts;
+                        }
+                        cx.notify();
+                    }),
+                ),
+            );
+            n += 1;
+            rows = rows.child(index_row(
+                n,
+                name,
+                Some(
+                    div()
+                        .child(tr(if plays {
+                            "Offline name · plays"
+                        } else {
+                            "Offline name"
+                        }))
+                        .into_any_element(),
+                ),
+                Some(actions.into_any_element()),
+                &t,
+            ));
+        }
+        rows = rows.children(self.skin_panel(cx));
+        n += 1;
+        let add = div()
+            .flex()
+            .items_center()
+            .gap(px(8.))
+            .child(self.field(Field::OfflineName, tr("A name, 3 to 16 letters"), 220., cx))
+            .child(
+                button("offline-add", "Add", Kind::Secondary, &t).on_click(cx.listener(
+                    |this, _: &ClickEvent, _, cx| {
+                        this.add_offline_name();
+                        cx.notify();
+                    },
+                )),
+            );
+        rows = rows.child(index_row(
+            n,
+            tr("Offline name"),
+            Some(
+                div()
+                    .child(tr(
+                        "Play offline under another name, and switch from the top bar. Online \
+                         servers don't take offline names.",
+                    ))
+                    .into_any_element(),
+            ),
+            Some(add.into_any_element()),
+            &t,
+        ));
+        (rows, n)
+    }
+}
diff --git a/launcher/src/theme.rs b/launcher/src/theme.rs
index 9d495a598..8ef6c43dc 100644
--- a/launcher/src/theme.rs
+++ b/launcher/src/theme.rs
@@ -4,6 +4,7 @@
 //! Mono for text (all bundled, SIL Open Font License).
 use gpui::{rgb, Hsla, WindowAppearance};
 use horizon_launcher::backend::Appearance;
+use horizon_launcher::themes::Accent;
 use horizon_theme as tokens;
 use std::time::Duration;
 
@@ -91,25 +92,18 @@ pub fn pinned_dark(choice: Appearance) -> Option<bool> {
 
 impl Theme {
     /// The pinned look (`pinned_dark`: dark unless the player picked another), the system's when
-    /// they asked to follow it.
-    pub fn for_appearance(choice: Appearance, system: WindowAppearance) -> Self {
+    /// they asked to follow it, in the player's accent.
+    pub fn for_appearance(choice: Appearance, accent: Accent, system: WindowAppearance) -> Self {
         let system_dark = !matches!(
             system,
             WindowAppearance::Light | WindowAppearance::VibrantLight
         );
-        if pinned_dark(choice).unwrap_or(system_dark) {
-            Self::dark()
+        let dark = pinned_dark(choice).unwrap_or(system_dark);
+        Self::from(accent.apply(if dark {
+            tokens::BLOCKS_DARK
         } else {
-            Self::light()
-        }
-    }
-
-    pub fn dark() -> Self {
-        Self::from(tokens::BLOCKS_DARK)
-    }
-
-    pub fn light() -> Self {
-        Self::from(tokens::BLOCKS_LIGHT)
+            tokens::BLOCKS_LIGHT
+        }))
     }
 
     fn from(p: tokens::Blocks) -> Self {
diff --git a/launcher/src/themes.rs b/launcher/src/themes.rs
new file mode 100644
index 000000000..7d12441bd
--- /dev/null
+++ b/launcher/src/themes.rs
@@ -0,0 +1,201 @@
+//! The player's own look, on top of Dark, Light or System: an accent colour and a picture behind
+//! Home.
+//!
+//! An accent is a hue. Horizon's violet is the default; another hue turns the violet tokens
+//! (`horizon_theme::Blocks`' accent and the main action's face, bevel and lip) to it, keeping
+//! their saturation and lightness, then darkens or lightens each just enough to read as well as
+//! the violet does: white on the face at 4.5:1, the accent at 3:1 on every background.
+use horizon_theme::{contrast, Blocks};
+use std::path::{Path, PathBuf};
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Accent {
+    #[default]
+    Violet,
+    Blue,
+    Teal,
+    Green,
+    Amber,
+    Red,
+    Pink,
+}
+
+impl Accent {
+    pub const ALL: [Accent; 7] = [
+        Self::Violet,
+        Self::Blue,
+        Self::Teal,
+        Self::Green,
+        Self::Amber,
+        Self::Red,
+        Self::Pink,
+    ];
+
+    /// Its name in `settings.json` and on the command line.
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Violet => "violet",
+            Self::Blue => "blue",
+            Self::Teal => "teal",
+            Self::Green => "green",
+            Self::Amber => "amber",
+            Self::Red => "red",
+            Self::Pink => "pink",
+        }
+    }
+
+    pub fn parse(name: &str) -> Option<Self> {
+        let name = name.trim().to_ascii_lowercase();
+        let name = if name == "purple" || name == "default" {
+            "violet"
+        } else {
+            &name
+        };
+        Self::ALL.into_iter().find(|a| a.name() == name)
+    }
+
+    /// Its hue in degrees; None for the violet, whose tokens stay as they are.
+    fn hue(self) -> Option<f32> {
+        match self {
+            Self::Violet => None,
+            Self::Blue => Some(212.),
+            Self::Teal => Some(176.),
+            Self::Green => Some(140.),
+            Self::Amber => Some(36.),
+            Self::Red => Some(356.),
+            Self::Pink => Some(322.),
+        }
+    }
+
+    /// `palette` with this accent.
+    pub fn apply(self, mut p: Blocks) -> Blocks {
+        let Some(hue) = self.hue() else {
+            return p;
+        };
+        let turn = |c: u32| {
+            let (_, s, l) = hsl(c);
+            (hue, s, l)
+        };
+        // The face holds white text.
+        let face = fit(turn(p.face), |c| contrast(p.on_face, c) >= 4.5, -1.);
+        let (_, _, face_l) = hsl(face);
+        let (h, s, l) = turn(p.face_bevel);
+        p.face_bevel = from_hsl(h, s, l.max(face_l + 0.08).min(0.92));
+        let (h, s, l) = turn(p.face_lip);
+        p.face_lip = from_hsl(h, s, l.min(face_l - 0.12).max(0.05));
+        p.face = face;
+        // The accent marks things on every background: lighter on dark, darker on light.
+        let grounds = [p.page, p.raised, p.button, p.panel, p.well];
+        let reads = |c: u32| grounds.iter().all(|&g| contrast(c, g) >= 3.2);
+        p.accent = fit(turn(p.accent), reads, if p.dark { 1. } else { -1. });
+        p
+    }
+}
+
+/// The colour's hue (degrees), saturation and lightness (0 to 1).
+fn hsl(c: u32) -> (f32, f32, f32) {
+    let [r, g, b] = [16, 8, 0].map(|s| ((c >> s) & 255) as f32 / 255.);
+    let (max, min) = (r.max(g).max(b), r.min(g).min(b));
+    let l = (max + min) / 2.;
+    if max == min {
+        return (0., 0., l);
+    }
+    let d = max - min;
+    let s = if l > 0.5 {
+        d / (2. - max - min)
+    } else {
+        d / (max + min)
+    };
+    let h = if max == r {
+        (g - b) / d + if g < b { 6. } else { 0. }
+    } else if max == g {
+        (b - r) / d + 2.
+    } else {
+        (r - g) / d + 4.
+    };
+    (h * 60., s, l)
+}
+
+fn from_hsl(h: f32, s: f32, l: f32) -> u32 {
+    let c = (1. - (2. * l - 1.).abs()) * s;
+    let x = c * (1. - ((h / 60.) % 2. - 1.).abs());
+    let m = l - c / 2.;
+    let (r, g, b) = match (h.rem_euclid(360.) / 60.) as u32 {
+        0 => (c, x, 0.),
+        1 => (x, c, 0.),
+        2 => (0., c, x),
+        3 => (0., x, c),
+        4 => (x, 0., c),
+        _ => (c, 0., x),
+    };
+    let byte = |v: f32| ((v + m).clamp(0., 1.) * 255.).round() as u32;
+    byte(r) << 16 | byte(g) << 8 | byte(b)
+}
+
+/// The colour, made lighter (`step` 1) or darker (-1) a little at a time until `good` holds.
+fn fit((h, s, l): (f32, f32, f32), good: impl Fn(u32) -> bool, step: f32) -> u32 {
+    let mut l = l;
+    for _ in 0..100 {
+        let c = from_hsl(h, s, l);
+        if good(c) || !(0.0..=1.0).contains(&l) {
+            return c;
+        }
+        l += step * 0.01;
+    }
+    from_hsl(h, s, l.clamp(0., 1.))
+}
+
+/// The pictures Home can show: what the decoders read.
+const PICTURES: [&str; 4] = ["png", "jpg", "jpeg", "webp"];
+/// A picture above this is refused: a screen's worth is far less.
+const MAX_BYTES: u64 = 40 << 20;
+
+/// Keeps `file` as Home's background in `dir` (`background-<hash>.<ext>`: a new picture gets a
+/// new name, so the window doesn't show the one it cached), after checking it is a picture, and
+/// returns the kept file's name. An older background goes.
+pub fn keep_background(dir: &Path, file: &Path) -> Result<String, String> {
+    let shown = file.display();
+    let ext = file
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(str::to_ascii_lowercase)
+        .filter(|e| PICTURES.contains(&e.as_str()))
+        .ok_or_else(|| format!("{shown}: a PNG, JPEG or WebP picture, please."))?;
+    let size = std::fs::metadata(file)
+        .map_err(|e| format!("{shown}: {e}"))?
+        .len();
+    if size > MAX_BYTES {
+        return Err(format!("{shown} is over 40 MB."));
+    }
+    let bytes = std::fs::read(file).map_err(|e| format!("{shown}: {e}"))?;
+    let (w, h) = image::ImageReader::new(std::io::Cursor::new(&bytes))
+        .with_guessed_format()
+        .ok()
+        .and_then(|r| r.into_dimensions().ok())
+        .ok_or_else(|| format!("{shown} isn't a picture the launcher can read."))?;
+    if w < 64 || h < 64 {
+        return Err(format!("{shown} is {w}×{h}: too small to fill Home."));
+    }
+    std::fs::create_dir_all(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let hash = crate::sources::sha1_hex(&bytes);
+    let name = format!("background-{}.{ext}", &hash[..12]);
+    std::fs::write(dir.join(&name), &bytes).map_err(|e| format!("{name}: {e}"))?;
+    for old in std::fs::read_dir(dir).into_iter().flatten().flatten() {
+        let other = old.file_name().to_string_lossy().into_owned();
+        if other.starts_with("background-") && other != name {
+            let _ = std::fs::remove_file(old.path());
+        }
+    }
+    Ok(name)
+}
+
+/// Home's background, if the player keeps one and it is still there.
+pub fn background(dir: &Path, name: Option<&str>) -> Option<PathBuf> {
+    let name = name.filter(|n| n.starts_with("background-") && !n.contains(['/', '\\']))?;
+    Some(dir.join(name)).filter(|p| p.is_file())
+}
+
+#[cfg(test)]
+#[path = "themes/tests.rs"]
+mod tests;
diff --git a/launcher/src/themes/tests.rs b/launcher/src/themes/tests.rs
new file mode 100644
index 000000000..e66a5e083
--- /dev/null
+++ b/launcher/src/themes/tests.rs
@@ -0,0 +1,107 @@
+use super::*;
+use horizon_theme::{BLOCKS_DARK, BLOCKS_LIGHT};
+
+fn blend(top: u32, under: u32, alpha: f32) -> u32 {
+    let channel = |shift: u32| {
+        let (a, b) = ((top >> shift & 0xff) as f32, (under >> shift & 0xff) as f32);
+        ((a * alpha + b * (1. - alpha)).round() as u32) << shift
+    };
+    channel(16) | channel(8) | channel(0)
+}
+
+#[test]
+fn every_accent_reads_as_well_as_the_violet() {
+    for base in [BLOCKS_DARK, BLOCKS_LIGHT] {
+        for accent in Accent::ALL {
+            let p = accent.apply(base);
+            let what = format!(
+                "{} {}",
+                accent.name(),
+                if p.dark { "dark" } else { "light" }
+            );
+            let on_face = contrast(p.on_face, p.face);
+            assert!(on_face >= 4.5, "{what}: text on the face {on_face:.2}");
+            for g in [p.page, p.raised, p.button, p.panel, p.well] {
+                let ring = contrast(p.accent, g);
+                assert!(ring >= 3.0, "{what}: accent on {g:06x} {ring:.2}");
+            }
+            // Text over a selected suggestion (the launcher's theme::SELECTION).
+            let selected = contrast(p.ink, blend(p.accent, p.panel, 0.22));
+            assert!(selected >= 4.5, "{what}: text on a selection {selected:.2}");
+            let (_, _, face) = hsl(p.face);
+            assert!(
+                hsl(p.face_bevel).2 > face && hsl(p.face_lip).2 < face,
+                "{what}"
+            );
+            if accent != Accent::Violet {
+                let (h, _, _) = hsl(p.face);
+                let want = accent.hue().unwrap();
+                let off = ((h - want).rem_euclid(360.)).min((want - h).rem_euclid(360.));
+                assert!(off < 3., "{what}: face hue {h:.0}, not {want}");
+            }
+        }
+        let violet = Accent::Violet.apply(base);
+        assert_eq!((violet.accent, violet.face), (base.accent, base.face));
+    }
+}
+
+#[test]
+fn colours_go_to_hsl_and_back() {
+    for c in [
+        0x5b3fd6, 0x9a86ff, 0x000000, 0xffffff, 0x45c27a, 0xf0b84f, 0x123456,
+    ] {
+        let (h, s, l) = hsl(c);
+        assert_eq!(from_hsl(h, s, l), c, "{c:06x}");
+    }
+    assert_eq!(Accent::parse("Teal"), Some(Accent::Teal));
+    assert_eq!(Accent::parse("purple"), Some(Accent::Violet));
+    assert_eq!(Accent::parse("chartreuse"), None);
+    assert_eq!(serde_json::to_string(&Accent::Amber).unwrap(), "\"amber\"");
+}
+
+#[test]
+fn a_background_is_a_picture_kept_once() {
+    let root = std::env::temp_dir().join(format!("horizon-background-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&root);
+    std::fs::create_dir_all(&root).unwrap();
+    let picture = |name: &str, w: u32, h: u32| {
+        let path = root.join(name);
+        image::RgbImage::new(w, h).save(&path).unwrap();
+        path
+    };
+    let dir = root.join("data");
+    let png = picture("dusk.png", 160, 90);
+    let first = keep_background(&dir, &png).unwrap();
+    assert!(
+        first.starts_with("background-") && first.ends_with(".png"),
+        "{first}"
+    );
+    let jpg = picture("noon.jpg", 160, 90);
+    let second = keep_background(&dir, &jpg).unwrap();
+    assert!(second.ends_with(".jpg") && second != first, "{second}");
+    assert!(!dir.join(&first).exists(), "the older one goes");
+    assert_eq!(background(&dir, Some(&second)), Some(dir.join(&second)));
+    assert_eq!(background(&dir, Some(&first)), None, "gone");
+    assert_eq!(background(&dir, Some("../noon.jpg")), None);
+    assert_eq!(background(&dir, None), None);
+
+    let tiny = picture("tiny.png", 16, 16);
+    assert!(keep_background(&dir, &tiny)
+        .unwrap_err()
+        .contains("too small"));
+    let text = root.join("notes.txt");
+    std::fs::write(&text, "hi").unwrap();
+    assert!(keep_background(&dir, &text)
+        .unwrap_err()
+        .contains("PNG, JPEG or WebP"));
+    let fake = root.join("fake.png");
+    std::fs::write(&fake, "not a picture").unwrap();
+    assert!(keep_background(&dir, &fake)
+        .unwrap_err()
+        .contains("can read"));
+    assert!(
+        dir.join(&second).exists(),
+        "a refused file keeps the old one"
+    );
+    std::fs::remove_dir_all(&root).unwrap();
+}
diff --git a/launcher/src/themes_page.rs b/launcher/src/themes_page.rs
new file mode 100644
index 000000000..0f3ab890f
--- /dev/null
+++ b/launcher/src/themes_page.rs
@@ -0,0 +1,155 @@
+//! Settings' accent colour and Home background rows (`horizon_launcher::themes`).
+use super::*;
+use horizon_launcher::themes::{self, Accent};
+use std::path::PathBuf;
+
+/// Each accent's swatch, in points.
+const SWATCH: f32 = 26.;
+
+impl Launcher {
+    /// The theme Settings ask for, under the window's own light or dark.
+    pub(super) fn settings_theme(&self, window: &Window) -> Theme {
+        Theme::for_appearance(
+            self.settings.appearance,
+            self.settings.accent,
+            window.appearance(),
+        )
+    }
+
+    /// The picture behind Home, if the player keeps one.
+    pub(super) fn home_background(&self) -> Option<PathBuf> {
+        themes::background(&backend::data_dir(), self.settings.background.as_deref())
+    }
+
+    pub(super) fn accent_row(&self, cx: &mut Context<Self>) -> Div {
+        let t = self.theme;
+        let mut swatches = div().flex().gap(px(6.));
+        for accent in Accent::ALL {
+            let face = Theme::for_appearance(
+                if t.dark {
+                    backend::Appearance::Dark
+                } else {
+                    backend::Appearance::Light
+                },
+                accent,
+                gpui::WindowAppearance::Dark,
+            )
+            .face;
+            let chosen = self.settings.accent == accent;
+            swatches = swatches.child(
+                keyboard(
+                    div().id(SharedString::from(format!("accent-{}", accent.name()))),
+                    &t,
+                )
+                .size(px(SWATCH))
+                .bg(face)
+                .border_2()
+                .border_color(if chosen { t.ink } else { t.outline })
+                .cursor_pointer()
+                .when(chosen, |d| {
+                    d.flex()
+                        .items_center()
+                        .justify_center()
+                        .child(div().size(px(8.)).bg(t.on_face))
+                })
+                .on_click(cx.listener(move |this, _: &ClickEvent, window, cx| {
+                    this.settings.accent = accent;
+                    this.settings.save();
+                    this.theme = this.settings_theme(window);
+                    cx.notify();
+                })),
+            );
+        }
+        index_row(
+            0,
+            tr("Accent colour"),
+            Some(
+                div()
+                    .child(tr(
+                        "Horizon's violet by default. Every colour keeps text as easy to read.",
+                    ))
+                    .into_any_element(),
+            ),
+            Some(swatches.into_any_element()),
+            &t,
+        )
+    }
+
+    fn choose_background(&mut self, cx: &mut Context<Self>) {
+        let paths = cx.prompt_for_paths(PathPromptOptions {
+            files: true,
+            directories: false,
+            multiple: false,
+            prompt: Some(tr("Choose").to_string().into()),
+        });
+        cx.spawn(async move |this, cx| {
+            let Ok(Ok(Some(mut paths))) = paths.await else {
+                return;
+            };
+            let Some(path) = paths.pop() else {
+                return;
+            };
+            let _ = this.update(cx, |this, cx| {
+                this.take_background(&path);
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    fn take_background(&mut self, path: &std::path::Path) {
+        match themes::keep_background(&backend::data_dir(), path) {
+            Ok(name) => {
+                self.settings.background = Some(name);
+                self.settings.save();
+                self.background_error = None;
+            }
+            Err(e) => self.background_error = Some(e),
+        }
+    }
+
+    pub(super) fn home_background_row(&self, cx: &mut Context<Self>) -> Div {
+        let t = self.theme;
+        let custom = self.home_background().is_some();
+        let mut actions = div().flex().gap(px(4.)).child(
+            button(
+                "background-choose",
+                "Choose a picture…",
+                Kind::Secondary,
+                &t,
+            )
+            .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
+                this.choose_background(cx);
+                cx.notify();
+            })),
+        );
+        if custom {
+            actions = actions.child(
+                button("background-reset", "Landscape", Kind::Ghost, &t).on_click(cx.listener(
+                    |this, _: &ClickEvent, _, cx| {
+                        this.settings.background = None;
+                        this.settings.save();
+                        cx.notify();
+                    },
+                )),
+            );
+        }
+        let said = if custom {
+            tr("Your picture, behind Home, cropped to fill it.")
+        } else {
+            tr("Horizon's landscape. Pick a PNG, JPEG or WebP picture of your own.")
+        };
+        let detail = div().flex().flex_col().child(said.to_string()).children(
+            self.background_error
+                .clone()
+                .map(|e| div().text_color(t.danger).child(e)),
+        );
+        index_row(
+            0,
+            tr("Home background"),
+            Some(detail.into_any_element()),
+            Some(actions.into_any_element()),
+            &t,
+        )
+    }
+}
diff --git a/launcher/src/titlebar.rs b/launcher/src/titlebar.rs
index a023f7d7d..dbf0f966e 100644
--- a/launcher/src/titlebar.rs
+++ b/launcher/src/titlebar.rs
@@ -1,12 +1,25 @@
-//! Custom Windows chrome. Other platforms keep their native window decorations; on macOS,
-//! `apply_appearance` repaints that chrome (the title bar) to match the chosen look.
+//! Window chrome: Windows and Linux client-side decorations are custom drawn; macOS and Linux
+//! server-side decorations use the platform's native chrome.
 use crate::theme::Theme;
 use gpui::{Div, TitlebarOptions, Window};
 use horizon_launcher::backend::Appearance;
 
-/// Whether the launcher draws its own title bar (`render`) rather than the system.
+/// Whether Windows uses a transparent native title bar for the launcher's custom chrome.
 pub const DRAWN: bool = cfg!(target_os = "windows");
 
+pub fn draws_brand(window: &Window) -> bool {
+    #[cfg(target_os = "linux")]
+    return matches!(
+        window.window_decorations(),
+        gpui::Decorations::Client { .. }
+    );
+    #[cfg(not(target_os = "linux"))]
+    {
+        let _ = window;
+        DRAWN
+    }
+}
+
 pub fn options() -> TitlebarOptions {
     TitlebarOptions {
         title: Some("Horizon".into()),
@@ -15,15 +28,228 @@ pub fn options() -> TitlebarOptions {
     }
 }
 
-#[cfg(not(target_os = "windows"))]
+#[cfg(all(not(target_os = "windows"), not(target_os = "linux")))]
 pub fn render(_theme: &Theme, _window: &Window) -> Option<Div> {
     None
 }
 
+/// Draw the launcher's Linux title bar when the platform uses client-side decorations.
+#[cfg(target_os = "linux")]
+pub fn render(theme: &Theme, window: &Window) -> Option<Div> {
+    use crate::{blocks, mark};
+    use gpui::{div, prelude::*, px, Decorations, FontWeight, MouseButton};
+
+    if matches!(window.window_decorations(), Decorations::Server) {
+        return None;
+    }
+
+    let controls = window.window_controls();
+    let drag = div()
+        .id("window-drag")
+        .flex()
+        .flex_1()
+        .h_full()
+        .items_center()
+        .gap(px(8.))
+        .px(px(12.))
+        .on_mouse_down(MouseButton::Left, |_, window, _| window.start_window_move())
+        .child(mark(16., theme))
+        .child(blocks::pixel(13., FontWeight::MEDIUM).child("Horizon"));
+
+    let mut bar = div()
+        .flex()
+        .flex_none()
+        .items_center()
+        .h(px(32.))
+        .bg(theme.side)
+        .text_color(theme.muted)
+        .border_b_1()
+        .border_color(theme.outline)
+        .child(drag);
+
+    if controls.minimize {
+        let color = theme.ink_soft;
+        let hover = theme.raised;
+        bar = bar.child(
+            div()
+                .id("window-minimize")
+                .flex()
+                .flex_none()
+                .items_center()
+                .justify_center()
+                .w(px(46.))
+                .h_full()
+                .cursor_pointer()
+                .hover(move |style| style.bg(hover))
+                .child(div().w(px(10.)).h(px(1.)).bg(color))
+                .on_click(|_, window, _| window.minimize_window()),
+        );
+    }
+
+    if controls.maximize {
+        let color = theme.ink_soft;
+        let hover = theme.raised;
+        let maximized = window.is_maximized();
+        let square = || {
+            div()
+                .absolute()
+                .size(px(10.))
+                .border_1()
+                .border_color(color)
+        };
+        let icon = div().relative().size(px(14.));
+        let icon = if maximized {
+            icon.child(
+                div()
+                    .absolute()
+                    .left(px(4.))
+                    .top_0()
+                    .size(px(10.))
+                    .border_t_1()
+                    .border_r_1()
+                    .border_color(color),
+            )
+            .child(square().left(px(1.)).top(px(3.)))
+        } else {
+            icon.child(square().left(px(2.)).top(px(2.)))
+        };
+        bar = bar.child(
+            div()
+                .id("window-maximize")
+                .flex()
+                .flex_none()
+                .items_center()
+                .justify_center()
+                .w(px(46.))
+                .h_full()
+                .cursor_pointer()
+                .hover(move |style| style.bg(hover))
+                .child(icon)
+                .on_click(|_, window, _| window.zoom_window()),
+        );
+    }
+
+    let close_hover = theme.page;
+    let close_bg = theme.danger;
+    Some(
+        bar.child(
+            div()
+                .id("window-close")
+                .group("linux-window-close")
+                .flex()
+                .flex_none()
+                .items_center()
+                .justify_center()
+                .w(px(46.))
+                .h_full()
+                .cursor_pointer()
+                .hover(move |style| style.bg(close_bg).text_color(close_hover))
+                .child(
+                    blocks::icon("close", 14., theme.ink_soft)
+                        .group_hover("linux-window-close", move |style| {
+                            style.text_color(close_hover)
+                        }),
+                )
+                .on_click(|_, window, _| window.remove_window()),
+        ),
+    )
+}
+
+#[cfg(target_os = "linux")]
+pub fn resize_handles(window: &Window) -> Option<Div> {
+    use gpui::{div, prelude::*, px, CursorStyle, Decorations, MouseButton, ResizeEdge};
+
+    if matches!(window.window_decorations(), Decorations::Server) || window.is_maximized() {
+        return None;
+    }
+
+    let handle = |id, edge, cursor| {
+        div()
+            .id(id)
+            .absolute()
+            .cursor(cursor)
+            .on_mouse_down(MouseButton::Left, move |_, window, _| {
+                window.start_window_resize(edge)
+            })
+    };
+
+    Some(
+        div()
+            .absolute()
+            .size_full()
+            .child(
+                handle("resize-left", ResizeEdge::Left, CursorStyle::ResizeLeft)
+                    .left_0()
+                    .top(px(8.))
+                    .bottom(px(8.))
+                    .w(px(5.)),
+            )
+            .child(
+                handle("resize-right", ResizeEdge::Right, CursorStyle::ResizeRight)
+                    .right_0()
+                    .top(px(8.))
+                    .bottom(px(8.))
+                    .w(px(5.)),
+            )
+            .child(
+                handle("resize-bottom", ResizeEdge::Bottom, CursorStyle::ResizeDown)
+                    .bottom_0()
+                    .left(px(8.))
+                    .right(px(8.))
+                    .h(px(5.)),
+            )
+            .child(
+                handle(
+                    "resize-top-left",
+                    ResizeEdge::TopLeft,
+                    CursorStyle::ResizeUpLeftDownRight,
+                )
+                .left_0()
+                .top_0()
+                .size(px(8.)),
+            )
+            .child(
+                handle(
+                    "resize-top-right",
+                    ResizeEdge::TopRight,
+                    CursorStyle::ResizeUpRightDownLeft,
+                )
+                .right_0()
+                .top_0()
+                .size(px(8.)),
+            )
+            .child(
+                handle(
+                    "resize-bottom-left",
+                    ResizeEdge::BottomLeft,
+                    CursorStyle::ResizeUpRightDownLeft,
+                )
+                .left_0()
+                .bottom_0()
+                .size(px(8.)),
+            )
+            .child(
+                handle(
+                    "resize-bottom-right",
+                    ResizeEdge::BottomRight,
+                    CursorStyle::ResizeUpLeftDownRight,
+                )
+                .right_0()
+                .bottom_0()
+                .size(px(8.)),
+            ),
+    )
+}
+
+#[cfg(not(target_os = "linux"))]
+pub fn resize_handles(_: &Window) -> Option<Div> {
+    None
+}
+
 /// macOS keeps the window's appearance on the system setting, so a launcher set to Dark still
 /// draws a light title bar on a light desktop. Pin the NSWindow's appearance to the choice
 /// instead (`theme::pinned_dark`: `System` clears the pin, handing the chrome back to the
-/// system). Elsewhere the chrome is ours (Windows) or the system's (Linux).
+/// system). Windows uses custom chrome; Linux draws it only when the compositor requests it.
 #[cfg(target_os = "macos")]
 pub fn apply_appearance(window: &Window, choice: Appearance) {
     use objc2_app_kit::{
diff --git a/launcher/src/while_playing.rs b/launcher/src/while_playing.rs
new file mode 100644
index 000000000..f724d7e22
--- /dev/null
+++ b/launcher/src/while_playing.rs
@@ -0,0 +1,92 @@
+//! What the window does while the game runs (`backend::WhilePlaying`): stay, minimise, or hide
+//! (macOS), and come back to the front when the game closes, with how the run ended.
+use super::*;
+use backend::WhilePlaying;
+use gpui::AnyWindowHandle;
+
+pub(super) struct Aside {
+    /// The launcher's window.
+    window: AnyWindowHandle,
+    /// What the window did when the game started, to undo when it closes.
+    stepped: Option<WhilePlaying>,
+}
+
+impl Aside {
+    pub(super) fn new(window: AnyWindowHandle) -> Self {
+        Aside {
+            window,
+            stepped: None,
+        }
+    }
+}
+
+impl Launcher {
+    /// The game started: get out of its way as the player asked. Read from `settings.json`, so
+    /// `horizon-launcher settings while-playing …` counts at once.
+    pub(super) fn step_aside(&mut self, cx: &mut Context<Self>) {
+        self.settings.while_playing = Settings::load().while_playing;
+        let how = self.settings.while_playing.here();
+        if how == WhilePlaying::Stay {
+            return;
+        }
+        let window = self.aside.window;
+        self.aside.stepped = Some(how);
+        cx.defer(move |cx| match how {
+            WhilePlaying::Hide => cx.hide(),
+            _ => {
+                let _ = window.update(cx, |_, window, _| window.minimize_window());
+            }
+        });
+    }
+
+    /// The game closed: back to the front, where its play time, errors and log are.
+    pub(super) fn come_back(&mut self, cx: &mut Context<Self>) {
+        if self.aside.stepped.take().is_none() {
+            return;
+        }
+        let window = self.aside.window;
+        cx.defer(move |cx| {
+            cx.activate(true);
+            let _ = window.update(cx, |_, window, _| window.activate_window());
+        });
+    }
+
+    /// Settings' row for it.
+    pub(super) fn while_playing_row(&self, n: usize, cx: &mut Context<Self>) -> Div {
+        let t = self.theme;
+        let mut options = vec![
+            (WhilePlaying::Stay, "Stay"),
+            (WhilePlaying::Minimize, "Minimise"),
+        ];
+        if cfg!(target_os = "macos") {
+            options.push((WhilePlaying::Hide, "Hide"));
+        }
+        let current = self.settings.while_playing.here();
+        let picker = segments("while-playing", &options, current, &t, {
+            let this = cx.entity().downgrade();
+            move |choice, _, cx| {
+                let _ = this.update(cx, |this, cx| {
+                    this.settings.while_playing = choice;
+                    this.settings.save();
+                    cx.notify();
+                });
+            }
+        });
+        let said = match current {
+            WhilePlaying::Stay => "The launcher stays open while you play.",
+            WhilePlaying::Minimize => {
+                "The launcher goes down when the game starts, and comes back when it closes."
+            }
+            WhilePlaying::Hide => {
+                "The launcher hides when the game starts, and comes back when it closes."
+            }
+        };
+        index_row(
+            n,
+            tr("While playing"),
+            Some(div().child(tr(said)).into_any_element()),
+            Some(picker.into_any_element()),
+            &t,
+        )
+    }
+}
diff --git a/launcher/src/worlds.rs b/launcher/src/worlds.rs
new file mode 100644
index 000000000..3317ab1b8
--- /dev/null
+++ b/launcher/src/worlds.rs
@@ -0,0 +1,260 @@
+//! An instance's single-player worlds (`saves/` in its game folder): what each is, and backing
+//! up, copying and deleting them. Backups are made as vanilla's Make Backup makes them
+//! (`LevelStorageAccess.makeWorldBackup`): `backups/<yyyy-MM-dd_HH-mm-ss>_<folder>.zip` in the
+//! game folder, every file under `<folder>/` but the world's `session.lock`.
+use horizon_world::nbt::{self, Limits, Tag};
+use std::fs;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+/// The lock a running game holds on a world; vanilla's backups leave it out.
+const LOCK: &str = "session.lock";
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct World {
+    /// Its folder's name under `saves/`, the id commands take.
+    pub folder: String,
+    pub path: PathBuf,
+    /// `LevelName`, else the folder's name.
+    pub name: String,
+    /// Survival, Creative, Adventure, Spectator or Hardcore.
+    pub mode: &'static str,
+    /// `LastPlayed`, else when level.dat changed.
+    pub last_played: SystemTime,
+    /// The version that last saved it (`Version.Name`).
+    pub version: Option<String>,
+    /// Bytes on disk, every file in its folder.
+    pub size: u64,
+    /// `icon.png`, the picture the game took of it.
+    pub icon: Option<PathBuf>,
+}
+
+/// The worlds in a game folder's `saves/`, the last played first.
+pub fn list(home: &Path) -> Vec<World> {
+    let mut worlds: Vec<World> = fs::read_dir(home.join("saves"))
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter_map(|e| read(&e.path()))
+        .collect();
+    worlds.sort_by_key(|w| std::cmp::Reverse(w.last_played));
+    worlds
+}
+
+/// level.dat: gzip, as vanilla writes it, or plain.
+fn level_dat(path: &Path) -> Option<Tag> {
+    let bytes = fs::read(path).ok()?;
+    let mut raw = Vec::new();
+    let raw = match flate2::read::GzDecoder::new(&bytes[..])
+        .take(64 << 20)
+        .read_to_end(&mut raw)
+    {
+        Ok(_) => raw,
+        Err(_) => bytes,
+    };
+    Some(nbt::read_named(&raw, Limits::default()).ok()?.0.tag)
+}
+
+fn read(path: &Path) -> Option<World> {
+    let dat = path.join("level.dat");
+    let changed = fs::metadata(&dat).and_then(|m| m.modified()).ok()?;
+    let folder = path.file_name()?.to_string_lossy().into_owned();
+    let root = level_dat(&dat);
+    let data = root.as_ref().and_then(|r| r.get("Data"));
+    let field = |key: &str| data.and_then(|d| d.get(key));
+    let number = |tag: Option<&Tag>| match tag {
+        Some(Tag::Byte(v)) => i64::from(*v),
+        Some(Tag::Int(v)) => i64::from(*v),
+        Some(Tag::Long(v)) => *v,
+        _ => 0,
+    };
+    let text = |tag: Option<&Tag>| match tag {
+        Some(Tag::String(s)) => Some(s.to_string_lossy()),
+        _ => None,
+    };
+    // 26.3 keeps hardcore with the difficulty; older saves at the top of Data.
+    let hardcore = number(field("difficulty_settings").and_then(|d| d.get("hardcore"))) != 0
+        || number(field("hardcore")) != 0;
+    let mode = match (hardcore, number(field("GameType"))) {
+        (true, _) => "Hardcore",
+        (_, 1) => "Creative",
+        (_, 2) => "Adventure",
+        (_, 3) => "Spectator",
+        _ => "Survival",
+    };
+    let last_played = match number(field("LastPlayed")) {
+        millis if millis > 0 => UNIX_EPOCH + Duration::from_millis(millis as u64),
+        _ => changed,
+    };
+    let icon = path.join("icon.png");
+    Some(World {
+        name: text(field("LevelName"))
+            .filter(|n| !n.trim().is_empty())
+            .unwrap_or_else(|| folder.clone()),
+        folder,
+        path: path.to_path_buf(),
+        mode,
+        last_played,
+        version: text(field("Version").and_then(|v| v.get("Name"))),
+        size: size(path),
+        icon: icon.is_file().then_some(icon),
+    })
+}
+
+fn size(dir: &Path) -> u64 {
+    fs::read_dir(dir)
+        .into_iter()
+        .flatten()
+        .flatten()
+        .map(|e| match e.file_type() {
+            Ok(t) if t.is_dir() => size(&e.path()),
+            Ok(_) => e.metadata().map_or(0, |m| m.len()),
+            Err(_) => 0,
+        })
+        .sum()
+}
+
+/// The world in `home` a command names: its folder, or its name (any case).
+pub fn find(home: &Path, query: &str) -> Result<World, String> {
+    let all = list(home);
+    all.iter()
+        .find(|w| w.folder == query)
+        .or_else(|| all.iter().find(|w| w.name.eq_ignore_ascii_case(query)))
+        .cloned()
+        .ok_or_else(|| format!("No world {query} in {}", home.join("saves").display()))
+}
+
+/// `base`, else `base (1)`, `base (2)`... from the `first` count: the first name free in `dir`
+/// (vanilla's `FileUtil.findAvailableName`, after making the name safe for every file system).
+fn free_name(dir: &Path, base: &str, suffix: &str, first: u32) -> String {
+    let safe: String = base
+        .chars()
+        .map(|c| match c {
+            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '_',
+            c if c.is_control() => '_',
+            c => c,
+        })
+        .collect();
+    let safe = safe.trim_matches(|c: char| c == '.' || c.is_whitespace());
+    let safe = if safe.is_empty() { "World" } else { safe };
+    (first..)
+        .map(|n| match n {
+            0 => format!("{safe}{suffix}"),
+            n => format!("{safe} ({n}){suffix}"),
+        })
+        .find(|name| !dir.join(name).exists())
+        .unwrap()
+}
+
+/// Zips the world into the game folder's `backups/`, as vanilla's Make Backup does. Returns the
+/// zip's path.
+pub fn backup(home: &Path, world: &World) -> Result<PathBuf, String> {
+    backup_at(home, world, chrono::Local::now())
+}
+
+fn backup_at(
+    home: &Path,
+    world: &World,
+    now: chrono::DateTime<chrono::Local>,
+) -> Result<PathBuf, String> {
+    let dir = home.join("backups");
+    fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+    let prefix = format!("{}_{}", now.format("%Y-%m-%d_%H-%M-%S"), world.folder);
+    let zip_path = dir.join(free_name(&dir, &prefix, ".zip", 0));
+    let made = (|| -> std::io::Result<()> {
+        let mut zip = zip::ZipWriter::new(std::io::BufWriter::new(fs::File::create(&zip_path)?));
+        let options = zip::write::SimpleFileOptions::default()
+            .compression_method(zip::CompressionMethod::Deflated)
+            .large_file(true);
+        let mut stack = vec![world.path.clone()];
+        while let Some(dir) = stack.pop() {
+            let mut entries: Vec<_> = fs::read_dir(&dir)?.collect::<Result<_, _>>()?;
+            entries.sort_by_key(|e| e.file_name());
+            for e in entries {
+                let path = e.path();
+                if e.file_type()?.is_dir() {
+                    stack.push(path);
+                    continue;
+                }
+                if path.file_name() == Some(LOCK.as_ref()) {
+                    continue;
+                }
+                let relative = path.strip_prefix(&world.path).unwrap_or(&path);
+                let mut entry = world.folder.clone();
+                for part in relative.components() {
+                    entry.push('/');
+                    entry.push_str(&part.as_os_str().to_string_lossy());
+                }
+                zip.start_file(entry, options)?;
+                std::io::copy(&mut fs::File::open(&path)?, &mut zip)?;
+            }
+        }
+        zip.finish()?.flush()
+    })();
+    made.map(|()| zip_path.clone()).map_err(|e| {
+        let _ = fs::remove_file(&zip_path);
+        format!("Could not back up {}: {e}", world.name)
+    })
+}
+
+/// Copies the world into a new folder of the same `saves/`, named "<name> (1)", "<name> (2)"...
+/// and gives the copy that name in its level.dat so the game's list tells them apart.
+pub fn copy(world: &World) -> Result<World, String> {
+    let saves = world.path.parent().ok_or("A world folder has a parent")?;
+    let folder = free_name(saves, &world.name, "", 1);
+    let to = saves.join(&folder);
+    let made = copy_dir(&world.path, &to).and_then(|()| rename_level(&to, &folder));
+    if let Err(e) = made {
+        let _ = fs::remove_dir_all(&to);
+        return Err(format!("Could not copy {}: {e}", world.name));
+    }
+    read(&to).ok_or_else(|| format!("{} has no level.dat", to.display()))
+}
+
+fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
+    fs::create_dir_all(to)?;
+    for e in fs::read_dir(from)? {
+        let e = e?;
+        let target = to.join(e.file_name());
+        if e.file_type()?.is_dir() {
+            copy_dir(&e.path(), &target)?;
+        } else if e.file_name() != LOCK {
+            fs::copy(e.path(), target)?;
+        }
+    }
+    Ok(())
+}
+
+/// Sets `Data.LevelName`; a level.dat that can't be read is left as it is.
+fn rename_level(world: &Path, name: &str) -> std::io::Result<()> {
+    let dat = world.join("level.dat");
+    let Some(mut root) = level_dat(&dat) else {
+        return Ok(());
+    };
+    let Some(Tag::Compound(data)) = root.get_mut("Data") else {
+        return Ok(());
+    };
+    data.insert("LevelName".into(), Tag::String(name.into()));
+    let bytes = nbt::write_named(
+        &nbt::NamedTag {
+            name: "".into(),
+            tag: root,
+        },
+        Limits::default(),
+    )
+    .map_err(std::io::Error::other)?;
+    let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+    gz.write_all(&bytes)?;
+    fs::write(dat, gz.finish()?)
+}
+
+/// Moves the world to the system's trash, where the player can still get it back.
+pub fn delete(world: &World) -> Result<(), String> {
+    crate::desktop_seams::to_trash(&world.path)
+        .map_err(|e| format!("Could not move {} to the trash: {e}", world.name))
+}
+
+#[cfg(test)]
+#[path = "worlds/tests.rs"]
+mod tests;
diff --git a/launcher/src/worlds/tests.rs b/launcher/src/worlds/tests.rs
new file mode 100644
index 000000000..b19de80b0
--- /dev/null
+++ b/launcher/src/worlds/tests.rs
@@ -0,0 +1,157 @@
+use super::*;
+use chrono::TimeZone;
+
+fn scratch(name: &str) -> PathBuf {
+    let root = std::env::temp_dir().join(format!(
+        "horizon-launcher-worlds-{name}-{}",
+        std::process::id()
+    ));
+    let _ = fs::remove_dir_all(&root);
+    fs::create_dir_all(&root).unwrap();
+    root
+}
+
+/// A world as the game saves it: a gzip level.dat with `data`'s fields under `Data`.
+fn world(home: &Path, folder: &str, data: Vec<(&str, Tag)>) -> PathBuf {
+    let dir = home.join("saves").join(folder);
+    fs::create_dir_all(dir.join("region")).unwrap();
+    let root = Tag::compound([("Data", Tag::compound(data))]);
+    let bytes = nbt::write_named(
+        &nbt::NamedTag {
+            name: "".into(),
+            tag: root,
+        },
+        Limits::default(),
+    )
+    .unwrap();
+    let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+    gz.write_all(&bytes).unwrap();
+    fs::write(dir.join("level.dat"), gz.finish().unwrap()).unwrap();
+    fs::write(dir.join("region/r.0.0.mca"), [7u8; 1000]).unwrap();
+    fs::write(dir.join(LOCK), "lock").unwrap();
+    dir
+}
+
+fn name(n: &str) -> Tag {
+    Tag::String(n.into())
+}
+
+#[test]
+fn lists_what_each_world_is() {
+    let home = scratch("list");
+    let survival = world(
+        &home,
+        "Survival",
+        vec![
+            ("LevelName", name("My survival")),
+            ("GameType", Tag::Int(0)),
+            ("LastPlayed", Tag::Long(1_700_000_000_000)),
+            ("Version", Tag::compound([("Name", name("26.3"))])),
+        ],
+    );
+    fs::write(survival.join("icon.png"), "png").unwrap();
+    world(
+        &home,
+        "Hard",
+        vec![
+            ("LevelName", name("Hard")),
+            ("GameType", Tag::Int(0)),
+            ("LastPlayed", Tag::Long(1_800_000_000_000)),
+            (
+                "difficulty_settings",
+                Tag::compound([("hardcore", Tag::Byte(1))]),
+            ),
+        ],
+    );
+    world(
+        &home,
+        "Old",
+        vec![
+            ("GameType", Tag::Int(1)),
+            ("hardcore", Tag::Byte(0)),
+            ("LastPlayed", Tag::Long(1_600_000_000_000)),
+        ],
+    );
+    fs::create_dir_all(home.join("saves/not a world")).unwrap();
+
+    let all = list(&home);
+    let names: Vec<&str> = all.iter().map(|w| w.name.as_str()).collect();
+    assert_eq!(names, ["Hard", "My survival", "Old"]);
+    assert_eq!(all[0].mode, "Hardcore");
+    assert_eq!(all[1].mode, "Survival");
+    assert_eq!(all[1].folder, "Survival");
+    assert_eq!(all[1].version.as_deref(), Some("26.3"));
+    assert_eq!(all[1].icon, Some(survival.join("icon.png")));
+    assert_eq!(
+        all[1].last_played,
+        UNIX_EPOCH + Duration::from_millis(1_700_000_000_000)
+    );
+    assert!(all[1].size >= 1000);
+    // No LevelName: the folder's name.
+    assert_eq!(all[2].mode, "Creative");
+    assert_eq!(find(&home, "my SURVIVAL").unwrap().folder, "Survival");
+    assert!(find(&home, "nope").is_err());
+    fs::remove_dir_all(&home).unwrap();
+}
+
+#[test]
+fn a_backup_is_named_and_laid_out_as_vanillas() {
+    let home = scratch("backup");
+    world(&home, "World", vec![("LevelName", name("World"))]);
+    let w = find(&home, "World").unwrap();
+    let at = chrono::Local
+        .with_ymd_and_hms(2026, 10, 27, 1, 2, 3)
+        .unwrap();
+    let first = backup_at(&home, &w, at).unwrap();
+    assert_eq!(first, home.join("backups/2026-10-27_01-02-03_World.zip"));
+    // The same second again: the next free name.
+    let second = backup_at(&home, &w, at).unwrap();
+    assert_eq!(
+        second,
+        home.join("backups/2026-10-27_01-02-03_World (1).zip")
+    );
+    let mut zip = zip::ZipArchive::new(fs::File::open(&first).unwrap()).unwrap();
+    let mut entries: Vec<String> = zip.file_names().map(str::to_string).collect();
+    entries.sort();
+    assert_eq!(entries, ["World/level.dat", "World/region/r.0.0.mca"]);
+    let mut region = Vec::new();
+    zip.by_name("World/region/r.0.0.mca")
+        .unwrap()
+        .read_to_end(&mut region)
+        .unwrap();
+    assert_eq!(region, [7u8; 1000]);
+    fs::remove_dir_all(&home).unwrap();
+}
+
+#[test]
+fn a_copy_gets_the_next_free_name_in_its_folder_and_level_dat() {
+    let home = scratch("copy");
+    world(
+        &home,
+        "Base",
+        vec![("LevelName", name("Base")), ("GameType", Tag::Int(1))],
+    );
+    let base = find(&home, "Base").unwrap();
+    let copy1 = copy(&base).unwrap();
+    assert_eq!(copy1.folder, "Base (1)");
+    assert_eq!(copy1.name, "Base (1)");
+    assert_eq!(copy1.mode, "Creative");
+    assert!(!copy1.path.join(LOCK).exists());
+    assert_eq!(
+        fs::read(copy1.path.join("region/r.0.0.mca")).unwrap(),
+        [7u8; 1000]
+    );
+    assert_eq!(copy(&base).unwrap().folder, "Base (2)");
+    // The original is untouched.
+    assert_eq!(find(&home, "Base").unwrap(), base);
+    // A name that can't be a folder name is made safe.
+    assert_eq!(free_name(&home, "a/b: c?", "", 0), "a_b_ c_");
+    // A world whose folder isn't its name: the copy still gets a new name.
+    world(&home, "f", vec![("LevelName", name("Named"))]);
+    let named = copy(&find(&home, "f").unwrap()).unwrap();
+    assert_eq!(
+        (named.folder.as_str(), named.name.as_str()),
+        ("Named (1)", "Named (1)")
+    );
+    fs::remove_dir_all(&home).unwrap();
+}
diff --git a/launcher/src/worlds_page.rs b/launcher/src/worlds_page.rs
new file mode 100644
index 000000000..b850c306a
--- /dev/null
+++ b/launcher/src/worlds_page.rs
@@ -0,0 +1,327 @@
+//! The selected instance's worlds on Home (`horizon_launcher::worlds`): each with its picture,
+//! mode, version, when it was last played and its size, and Back up, Copy, Delete (to the
+//! trash, after a confirmation) and Open folder. Reading sizes and copying run in the background.
+use super::*;
+use horizon_launcher::worlds::{self, World};
+use std::path::{Path, PathBuf};
+
+#[derive(Default)]
+pub(super) struct Worlds {
+    /// The game folder the list is of, and the list as last read: kept on screen while it is
+    /// read again, so the page doesn't jump.
+    home: Option<PathBuf>,
+    list: Vec<World>,
+    fresh: bool,
+    reading: bool,
+    /// The world being backed up, copied or deleted now.
+    busy: Option<String>,
+    confirm_delete: Option<String>,
+    /// What the last action did (a backup's zip), or why it failed.
+    done: Option<Result<(String, Option<PathBuf>), String>>,
+}
+
+impl Worlds {
+    /// Read again on the next frame: the game may have saved, or an action changed the list.
+    pub(super) fn stale(&mut self) {
+        self.fresh = false;
+    }
+}
+
+/// "today", "yesterday", "3 days ago", else the date.
+pub(super) fn ago(when: std::time::SystemTime) -> String {
+    let when: chrono::DateTime<chrono::Local> = when.into();
+    let days = (chrono::Local::now().date_naive() - when.date_naive()).num_days();
+    match days {
+        ..=0 => tr("today").into(),
+        1 => tr("yesterday").into(),
+        2..=13 => trf("{days} days ago", &[("days", &days.to_string())]),
+        _ => when.format("%Y-%m-%d").to_string(),
+    }
+}
+
+enum Action {
+    Backup,
+    Copy,
+    Delete,
+}
+
+impl Launcher {
+    /// Reads the worlds of `home` in the background when the list is missing or of another
+    /// instance.
+    fn load_worlds(&mut self, home: PathBuf, cx: &mut Context<Self>) {
+        if self.worlds.home.as_ref() != Some(&home) {
+            self.worlds = Worlds {
+                home: Some(home.clone()),
+                ..Worlds::default()
+            };
+        }
+        if self.worlds.fresh || self.worlds.reading {
+            return;
+        }
+        self.worlds.reading = true;
+        let read = home.clone();
+        let task = cx
+            .background_executor()
+            .spawn(async move { worlds::list(&read) });
+        cx.spawn(async move |this, cx| {
+            let list = task.await;
+            let _ = this.update(cx, |this, cx| {
+                // Another instance may have been picked meanwhile.
+                if this.worlds.home.as_ref() == Some(&home) {
+                    this.worlds.list = list;
+                    this.worlds.fresh = true;
+                    this.worlds.reading = false;
+                }
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    fn world_action(&mut self, action: Action, world: World, cx: &mut Context<Self>) {
+        let Some(home) = self.worlds.home.clone() else {
+            return;
+        };
+        if self.worlds.busy.is_some() {
+            return;
+        }
+        self.worlds.busy = Some(world.folder.clone());
+        self.worlds.confirm_delete = None;
+        self.worlds.done = None;
+        let task = cx.background_executor().spawn(async move {
+            match action {
+                Action::Backup => worlds::backup(&home, &world)
+                    .map(|zip| (format!("{} backed up.", world.name), Some(zip))),
+                Action::Copy => {
+                    worlds::copy(&world).map(|c| (format!("Copied to {}.", c.name), None))
+                }
+                Action::Delete => worlds::delete(&world)
+                    .map(|()| (format!("{} moved to the trash.", world.name), None)),
+            }
+        });
+        cx.spawn(async move |this, cx| {
+            let done = task.await;
+            let _ = this.update(cx, |this, cx| {
+                this.worlds.busy = None;
+                this.worlds.done = Some(done);
+                this.worlds.stale();
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    /// Home's Worlds section, for the selected instance.
+    pub(super) fn worlds_section(&mut self, cx: &mut Context<Self>) -> Option<Div> {
+        let t = self.theme;
+        let home = self.selected_instance()?.home.clone();
+        self.load_worlds(home.clone(), cx);
+        let list = self.worlds.list.clone();
+        let mut section = div()
+            .flex()
+            .flex_col()
+            .gap(px(8.))
+            .child(section_title("Worlds", "globe", &t).mb(px(4.)));
+        match &self.worlds.done {
+            Some(Ok((message, zip))) => {
+                let mut line = div().flex().items_center().gap(px(12.)).child(
+                    text(theme::CAPTION)
+                        .text_color(t.muted)
+                        .child(message.clone()),
+                );
+                if let Some(zip) = zip.clone() {
+                    let dir = zip.parent().map(Path::to_path_buf).unwrap_or(zip);
+                    line = line.child(
+                        button("world-backups", "Open backups", Kind::Ghost, &t)
+                            .on_click(move |_, _, cx| cx.open_with_system(&dir)),
+                    );
+                }
+                section = section.child(line);
+            }
+            Some(Err(e)) => section = section.child(notice(e.clone(), &t)),
+            None => {}
+        }
+        if list.is_empty() {
+            let saves = home.join("saves");
+            return Some(
+                section.child(
+                    div()
+                        .flex()
+                        .items_center()
+                        .justify_between()
+                        .child(
+                            text(theme::CAPTION)
+                                .text_color(t.muted)
+                                .child("No worlds yet: they appear here once you play one."),
+                        )
+                        .child(
+                            button("worlds-folder", "Open folder", Kind::Ghost, &t).on_click(
+                                move |_, _, cx| {
+                                    let _ = std::fs::create_dir_all(&saves);
+                                    cx.open_with_system(&saves);
+                                },
+                            ),
+                        ),
+                ),
+            );
+        }
+        for (i, w) in list.into_iter().enumerate() {
+            let row = self.world_row(i, w.clone(), cx);
+            section = section
+                .child(self.world_drop_target(i, &w, row, cx))
+                .children(self.world_packs_panel(&w, cx));
+        }
+        Some(section)
+    }
+
+    fn world_row(&mut self, i: usize, w: World, cx: &mut Context<Self>) -> Div {
+        let t = self.theme;
+        let busy = self.worlds.busy.is_some();
+        let this_busy = self.worlds.busy.as_ref() == Some(&w.folder);
+        let confirming = self.worlds.confirm_delete.as_ref() == Some(&w.folder);
+        let picture = match &w.icon {
+            Some(icon) => div()
+                .flex_none()
+                .size(px(48.))
+                .border_2()
+                .border_color(t.outline)
+                .child(gpui::img(icon.clone()).size(px(44.)))
+                .into_any_element(),
+            None => div()
+                .flex()
+                .flex_none()
+                .items_center()
+                .justify_center()
+                .size(px(48.))
+                .border_2()
+                .border_color(t.outline)
+                .bg(t.well)
+                .child(blocks::icon("image", 22., t.muted))
+                .into_any_element(),
+        };
+        let mut facts = vec![w.mode.to_string()];
+        facts.extend(w.version.clone());
+        facts.push(ago(w.last_played));
+        facts.push(megabytes(w.size));
+        let act = |id: &str, label: &'static str, kind: Kind| {
+            let b = button(SharedString::from(format!("{id}-{i}")), label, kind, &t);
+            if busy {
+                disabled(b)
+            } else {
+                b
+            }
+        };
+        let mut actions = div().flex().items_center().gap(px(6.));
+        if confirming {
+            let gone = w.clone();
+            actions = actions
+                .child(
+                    text(theme::CAPTION)
+                        .text_color(t.danger)
+                        .child("Move it to the trash?"),
+                )
+                .child(act("world-keep", "Keep", Kind::Ghost).on_click(cx.listener(
+                    |this, _: &ClickEvent, _, cx| {
+                        this.worlds.confirm_delete = None;
+                        cx.notify();
+                    },
+                )))
+                .child(
+                    act("world-trash", "Move to trash", Kind::Secondary).on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            this.world_action(Action::Delete, gone.clone(), cx);
+                            cx.notify();
+                        },
+                    )),
+                );
+        } else if this_busy {
+            actions = actions.child(text(theme::CAPTION).text_color(t.muted).child("Working…"));
+        } else {
+            let (backup, copy, folder) = (w.clone(), w.clone(), w.path.clone());
+            let (delete, play) = (w.folder.clone(), w.folder.clone());
+            let running = self.client.is_some() || self.starting_client.is_some();
+            let play_button = act("world-play", "Play", Kind::Secondary);
+            let play_button = if running {
+                disabled(play_button)
+            } else {
+                play_button
+            };
+            actions = actions
+                .child(
+                    play_button.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
+                        this.quick_play("--world", play.clone());
+                        cx.notify();
+                    })),
+                )
+                .child(
+                    act("world-backup", "Back up", Kind::Ghost).on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            this.world_action(Action::Backup, backup.clone(), cx);
+                            cx.notify();
+                        },
+                    )),
+                )
+                .child(act("world-copy", "Copy", Kind::Ghost).on_click(cx.listener(
+                    move |this, _: &ClickEvent, _, cx| {
+                        this.world_action(Action::Copy, copy.clone(), cx);
+                        cx.notify();
+                    },
+                )))
+                .child(
+                    act("world-delete", "Delete", Kind::Ghost).on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            // Buttons look disabled while something runs, but still click.
+                            if this.worlds.busy.is_none() {
+                                this.worlds.confirm_delete = Some(delete.clone());
+                            }
+                            cx.notify();
+                        },
+                    )),
+                )
+                .child({
+                    let world = w.clone();
+                    let label = match self.world_packs_open(&w) {
+                        true => "Hide data packs",
+                        false => "Data packs",
+                    };
+                    act("world-packs", label, Kind::Ghost).on_click(cx.listener(
+                        move |this, _: &ClickEvent, _, cx| {
+                            this.toggle_world_packs(&world);
+                            cx.notify();
+                        },
+                    ))
+                })
+                .child(
+                    act("world-folder", "Open folder", Kind::Ghost)
+                        .on_click(move |_, _, cx| cx.open_with_system(&folder)),
+                );
+        }
+        plate(&t)
+            .flex()
+            .items_center()
+            .gap(px(14.))
+            .px(px(14.))
+            .py(px(10.))
+            .child(picture)
+            .child(
+                div()
+                    .flex()
+                    .flex_col()
+                    .flex_1()
+                    .min_w_0()
+                    .child(
+                        blocks::pixel(15., FontWeight::MEDIUM)
+                            .text_color(t.ink)
+                            .truncate()
+                            .child(w.name.clone()),
+                    )
+                    .child(
+                        text(theme::CAPTION)
+                            .text_color(t.muted)
+                            .truncate()
+                            .child(facts.join(" · ")),
+                    ),
+            )
+            .child(actions)
+    }
+}
diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDispenserOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDispenserOracle.java
index a529ae6ac..b83634f94 100644
--- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDispenserOracle.java
+++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaDispenserOracle.java
@@ -461,7 +461,9 @@ public final class VanillaDispenserOracle {
             line.append(' ').append(num(v.x)).append(' ').append(num(v.y)).append(' ').append(num(v.z));
             if (e instanceof ItemEntity item) line.append(' ').append(ParityData.canon(item.getItem()));
             if (e instanceof PrimedTnt tnt) line.append(" fuse=").append(tnt.getFuse());
-            result.add(line.toString());
+            // An orb that took others in (ExperienceOrb.tryMergeToExisting) prints once per
+            // count: whether orbs merge depends on entity ids, which Horizon doesn't share.
+            for (int n = e instanceof ExperienceOrb orb ? orbCount(orb) : 1; n > 0; n--) result.add(line.toString());
         }
         for (int i = 0; i < targets.size(); i++) result.add(describe(i, targets.get(i)));
         for (String s : w.log.toString().split("\n")) {
@@ -821,6 +823,16 @@ public final class VanillaDispenserOracle {
     }
 
     /** A target's state after dispensing: removal, equipment and readiness for shearing. */
+    static int orbCount(ExperienceOrb orb) {
+        try {
+            var f = ExperienceOrb.class.getDeclaredField("count");
+            f.setAccessible(true);
+            return f.getInt(orb);
+        } catch (ReflectiveOperationException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
     static String describe(int index, Entity e) {
         StringBuilder line = new StringBuilder("T " + index + " " + BuiltInRegistries.ENTITY_TYPE.getKey(e.getType()));
         if (e.isRemoved()) line.append(" removed");
diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPistonPushOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPistonPushOracle.java
new file mode 100644
index 000000000..f1cee2fc2
--- /dev/null
+++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPistonPushOracle.java
@@ -0,0 +1,78 @@
+package dev.horizonlab.parity;
+import com.google.gson.*;
+import java.io.*;
+import java.lang.reflect.*;
+import java.nio.file.*;
+import java.util.*;
+import net.minecraft.core.*;
+import net.minecraft.world.entity.*;
+import net.minecraft.world.entity.monster.zombie.Zombie;
+import net.minecraft.world.level.block.*;
+import net.minecraft.world.level.block.piston.*;
+import net.minecraft.world.phys.*;
+import net.minecraft.world.phys.shapes.*;
+/**
+ * The real moving-piston push maths: PistonMath.getMovementArea,
+ * moveByPositionAndProgress, getMovement, the moveCollidedEntities loop over
+ * the block's own boxes, and moveStuckEntities' box and matchesStickyCritera.
+ * fixEntityWithinPistonBase is left out: it moves the entity
+ * (`Entity.move(MoverType.PISTON, ...)`), which needs a live level, so the
+ * Rust side is covered by its own unit tests.
+ */
+public final class VanillaPistonPushOracle {
+ private static float number(JsonElement v){return Float.intBitsToFloat(Integer.parseUnsignedInt(v.getAsString(),16));}
+ private static double dbl(JsonElement v){return Double.longBitsToDouble(Long.parseUnsignedLong(v.getAsString(),16));}
+ private static AABB box(JsonElement v){var a=v.getAsJsonArray();return new AABB(dbl(a.get(0)),dbl(a.get(1)),dbl(a.get(2)),dbl(a.get(3)),dbl(a.get(4)),dbl(a.get(5)));}
+ private static void line(PrintWriter out,String name,AABB b){out.printf(name+" %016x %016x %016x %016x %016x %016x%n",Double.doubleToLongBits(b.minX),Double.doubleToLongBits(b.minY),Double.doubleToLongBits(b.minZ),Double.doubleToLongBits(b.maxX),Double.doubleToLongBits(b.maxY),Double.doubleToLongBits(b.maxZ));}
+ private static Field field(Class<?> c,String name)throws Exception{var f=c.getDeclaredField(name);f.setAccessible(true);return f;}
+ private static Method method(Class<?> c,String name,Class<?>...types)throws Exception{var m=c.getDeclaredMethod(name,types);m.setAccessible(true);return m;}
+ @SuppressWarnings("unchecked") public static void main(String[] args)throws Exception {
+  net.minecraft.SharedConstants.tryDetectVersion();net.minecraft.server.Bootstrap.bootStrap();Path dir=Path.of(args[1]);
+  var allocator=Class.forName("sun.misc.Unsafe");var uf=allocator.getDeclaredField("theUnsafe");uf.setAccessible(true);var unsafe=uf.get(null);var allocate=allocator.getMethod("allocateInstance",Class.class);
+  var progress=field(PistonMovingBlockEntity.class,"progress");
+  var movedBy=method(PistonMovingBlockEntity.class,"moveByPositionAndProgress",BlockPos.class,AABB.class,PistonMovingBlockEntity.class);
+  var extended=method(PistonMovingBlockEntity.class,"getExtendedProgress",float.class);
+  var getMovement=method(PistonMovingBlockEntity.class,"getMovement",AABB.class,Direction.class,AABB.class);
+  var matches=method(PistonMovingBlockEntity.class,"matchesStickyCritera",AABB.class,Entity.class,BlockPos.class);
+  var movementDir=method(PistonMovingBlockEntity.class,"getMovementDirection");
+  var position=field(Entity.class,"position");var onGroundField=field(Entity.class,"onGround");var supporting=field(Entity.class,"mainSupportingBlockPos");var bbField=field(Entity.class,"bb");
+  var faces=new Direction[]{Direction.EAST,Direction.WEST,Direction.UP,Direction.DOWN,Direction.SOUTH,Direction.NORTH};
+  try(var out=new PrintWriter(Files.newBufferedWriter(dir.resolve(args[0]+".txt")));var inputs=Files.lines(dir.resolve("inputs.txt"))) {
+   for(var line:(Iterable<String>)inputs::iterator) {
+    var f=JsonParser.parseString(line).getAsJsonObject();var v=f.getAsJsonArray("pos");var p=new BlockPos(v.get(0).getAsInt(),v.get(1).getAsInt(),v.get(2).getAsInt());
+    var direction=Direction.values()[f.get("direction").getAsInt()];
+    var piston=new PistonMovingBlockEntity(p,Blocks.MOVING_PISTON.defaultBlockState(),Blocks.STONE.defaultBlockState(),direction,f.get("extending").getAsBoolean(),f.get("source").getAsBoolean());
+    float current=number(f.get("progress"));
+    progress.setFloat(piston,current);
+    float newProgress=number(f.get("new_progress"));
+    double deltaProgress=newProgress-current;
+    Direction movement=(Direction)movementDir.invoke(piston);
+    AABB blockBox=box(f.get("block_box"));
+    AABB entityBox=box(f.get("entity"));
+    AABB movementBox=box(f.get("movement_box"));
+    out.printf("extended %08x%n",Float.floatToIntBits((float)extended.invoke(piston,current)));
+    AABB origin=(AABB)movedBy.invoke(null,p,blockBox,piston);
+    line(out,"origin",origin);
+    line(out,"area",PistonMath.getMovementArea(blockBox,movement,deltaProgress));
+    for(var face:faces)out.printf("movement %s %016x%n",face.getSerializedName(),Double.doubleToLongBits((double)getMovement.invoke(null,movementBox,face,entityBox)));
+    double delta=0.0;boolean capped=false;
+    for(var value:f.getAsJsonArray("boxes")){
+     AABB movingAABB=PistonMath.getMovementArea((AABB)movedBy.invoke(null,p,box(value),piston),movement,deltaProgress);
+     if(movingAABB.intersects(entityBox)){delta=Math.max(delta,(double)getMovement.invoke(null,movingAABB,movement,entityBox));if(delta>=deltaProgress){capped=true;break;}}
+    }
+    double collided=delta<=0.0?0.0:Math.min(delta,deltaProgress)+0.01;
+    out.printf("collided %016x %b%n",Double.doubleToLongBits(collided),capped);
+    line(out,"search",PistonMath.getMovementArea(origin,movement,deltaProgress).minmax(origin));
+    AABB sticky=(AABB)movedBy.invoke(null,p,new AABB(0.0,dbl(f.get("sticky_top")),0.0,1.0,1.5000010000000001,1.0),piston);
+    line(out,"sticky",sticky);
+    boolean pushable=f.get("reaction").getAsInt()==0;
+    var entity=(Entity)allocate.invoke(unsafe,pushable?Zombie.class:Marker.class);
+    position.set(entity,new Vec3(dbl(f.get("entity_x")),0.0,dbl(f.get("entity_z"))));
+    bbField.set(entity,entityBox);
+    onGroundField.setBoolean(entity,f.get("on_ground").getAsBoolean());
+    supporting.set(entity,f.get("supported").getAsBoolean()?Optional.of(p):Optional.empty());
+    out.printf("matches %b%n",(boolean)matches.invoke(null,sticky,entity,p));
+   }
+  }
+ }
+}
\ No newline at end of file
diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaProtocolClient.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaProtocolClient.java
index e37e898a3..fbb8ed2b0 100644
--- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaProtocolClient.java
+++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaProtocolClient.java
@@ -487,6 +487,17 @@ public final class VanillaProtocolClient {
         long deadCommandAt = 0;
         // When the client last sent where it is.
         long positionAt = 0;
+        // Chat lines and furnace slot changes received, and how many there were when the current step sent
+        // its command or click: a step goes on once the server answered, not after a fixed time (a busy
+        // server answers seconds late, and a click sent before the last one's reply carries a stale state id).
+        int replies = 0;
+        int repliesBefore = 0;
+        // A shift-click changes two slots, each its own packet, which a busy server can send ticks apart: a furnace
+        // step waits for both. A full resend of the menu counts as both.
+        int furnaceReplies = 0;
+        int furnaceBefore = 0;
+        // The furnace's lit and cooking totals received: the server sends them a tick after what changed them.
+        int furnaceData = 0;
         while (System.currentTimeMillis() < deadline) {
             Received r;
             try {
@@ -501,7 +512,7 @@ public final class VanillaProtocolClient {
                 if (entities != null && !entities.acceptSelf(packet) && step >= ENTITIES) entities.accept(packet);
                 if (r.type.equals("minecraft:chunk_batch_start")) ordered = false;
                 if (respawning && !respawned) {
-                    String line = respawnLine(r);
+                    String line = respawnLine(r, playerId);
                     // PlayerList.respawn ends with initInventoryMenu: what follows is the
                     // next ticks' (health, entity data, chunks), in each server's own order.
                     respawned = r.type.equals("minecraft:container_set_content") && respawnAt != null;
@@ -558,15 +569,18 @@ public final class VanillaProtocolClient {
                 } else if (packet instanceof net.minecraft.network.protocol.game.ClientboundContainerSetContentPacket p
                     && furnaceWindow > 0 && p.containerId() == furnaceWindow) {
                     furnaceState = p.stateId();
+                    furnaceReplies += 2;
                     record("play-furnace", "content " + p.items() + " carried " + p.carriedItem());
                 } else if (packet instanceof net.minecraft.network.protocol.game.ClientboundContainerSetSlotPacket p
                     && furnaceWindow > 0 && p.getContainerId() == furnaceWindow) {
                     furnaceState = p.getStateId();
+                    furnaceReplies++;
                     record("play-furnace", "slot " + p.getSlot() + " " + p.getItem());
                     if (p.getSlot() == 2 && !p.getItem().isEmpty() && smeltedAt == 0) smeltedAt = now;
                 } else if (packet instanceof net.minecraft.network.protocol.game.ClientboundContainerSetDataPacket p
                     && furnaceWindow > 0 && p.getContainerId() == furnaceWindow && (p.getId() == 1 || p.getId() == 3)) {
                     // Lit total and cooking total; the time left and the cooking timer follow the ticks.
+                    furnaceData++;
                     record("play-furnace", "data " + p.getId() + " " + p.getValue());
                 } else if (packet instanceof net.minecraft.network.protocol.game.ClientboundEntityEventPacket p
                     && step == 5 + REPLIES.length && (int) (byte) field(p, "eventId") == 28) {
@@ -583,13 +597,16 @@ public final class VanillaProtocolClient {
                     record("play-death", "command reply " + json(p.content()));
                     respawning = respawn();
                 } else if (packet instanceof ClientboundSystemChatPacket p && step > 0 && step < 5 + REPLIES.length) {
+                    replies++;
                     record("play-chat", "system " + p.overlay() + " " + json(p.content()));
                 } else if (packet instanceof ClientboundPlayerChatPacket p && step > 0 && step < 5 + REPLIES.length) {
+                    replies++;
                     record("play-chat", "player " + p.sender() + " " + p.index() + " " + p.body().content() + " " + p.signature().isPresent()
                         + " " + p.unsignedContent().map(VanillaProtocolClient::json) + " " + text(p.filterMask()) + " "
                         + p.chatType().chatType().getRegisteredName() + " " + json(p.chatType().name()) + " "
                         + p.chatType().targetName().map(VanillaProtocolClient::json));
                 } else if (packet instanceof ClientboundDisguisedChatPacket p && step > 0 && step < 5 + REPLIES.length) {
+                    replies++;
                     record("play-chat", "disguised " + json(p.message()) + " " + p.chatType().chatType().getRegisteredName());
                 } else if (packet instanceof net.minecraft.network.protocol.game.ClientboundAddEntityPacket p
                     && p.getType() == net.minecraft.world.entity.EntityTypes.SNOWBALL) {
@@ -679,20 +696,24 @@ public final class VanillaProtocolClient {
                 record("play-light-layers", inner.size() + " " + inner);
                 step = 1;
                 stepAt = now;
+                repliesBefore = replies;
                 send(new ServerboundChatPacket("hello from the parity client", Instant.now(), 0L, Optional.empty(),
                     new LastSeenMessages.Update(0, new BitSet(), (byte) 0)));
-            } else if (step == 1 && now - stepAt > 1500) {
+            } else if (step == 1 && answered(replies, repliesBefore, stepAt, now)) {
                 step = 2;
                 stepAt = now;
+                repliesBefore = replies;
                 send(new ServerboundChatCommandPacket("list"));
-            } else if (step >= 2 && step < 2 + REPLIES.length && now - stepAt > 1500) {
+            } else if (step >= 2 && step < 2 + REPLIES.length && answered(replies, repliesBefore, stepAt, now)) {
                 // Commands a player without operator rights may run, whose
                 // replies (a failure, a syntax error with its context, a
                 // failure with an argument) are compared component by component.
                 send(new ServerboundChatCommandPacket(REPLIES[step - 2]));
                 step++;
                 stepAt = now;
-            } else if (step == 2 + REPLIES.length && now - stepAt > 1500 && (villager >= 0 || now - stepAt > PATIENCE)) {
+                repliesBefore = replies;
+            } else if (step == 2 + REPLIES.length && answered(replies, repliesBefore, stepAt, now)
+                && (villager >= 0 || now - stepAt > PATIENCE)) {
                 // Right-click the villager (once the server sent it): the trading screen and its offers.
                 record("play-trade", "villager " + (villager >= 0));
                 if (villager >= 0) {
@@ -739,9 +760,13 @@ public final class VanillaProtocolClient {
                 send(new net.minecraft.network.protocol.game.ServerboundUseItemOnPacket(net.minecraft.world.InteractionHand.MAIN_HAND,
                     new net.minecraft.world.phys.BlockHitResult(net.minecraft.world.phys.Vec3.atCenterOf(furnace),
                         net.minecraft.core.Direction.NORTH, furnace, false), 1));
+                furnaceBefore = furnaceReplies;
                 step++;
                 stepAt = now;
-            } else if (step >= 8 + REPLIES.length && step <= 10 + REPLIES.length && furnaceWindow > 0 && now - stepAt > 1500
+            } else if (step >= 8 + REPLIES.length && step <= 10 + REPLIES.length && furnaceWindow > 0
+                && answered(furnaceReplies, furnaceBefore + 1, stepAt, now)
+                // Both totals with the window, then the cooking total the ore set, then the lit total the coal set.
+                && (furnaceData >= step - 6 - REPLIES.length || now - stepAt > PATIENCE)
                 // The ingot out once the furnace made it (200 ticks), and its tick's other changes came.
                 && (step < 10 + REPLIES.length || smeltedAt > 0 && now - smeltedAt > 1000 || now - stepAt > 10_000 + PATIENCE)) {
                 // Shift-click the ore (hotbar 0) into the input, the coal (hotbar 1) into the
@@ -752,9 +777,10 @@ public final class VanillaProtocolClient {
                 send(new net.minecraft.network.protocol.game.ServerboundContainerClickPacket(furnaceWindow, furnaceState, (short) slot,
                     (byte) 0, net.minecraft.world.inventory.ContainerInput.QUICK_MOVE,
                     new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>(), net.minecraft.network.HashedStack.EMPTY));
+                furnaceBefore = furnaceReplies;
                 step++;
                 stepAt = now;
-            } else if (step == 11 + REPLIES.length && now - stepAt > 1500) {
+            } else if (step == 11 + REPLIES.length && answered(furnaceReplies, furnaceBefore + 1, stepAt, now)) {
                 send(new net.minecraft.network.protocol.game.ServerboundContainerClosePacket(furnaceWindow));
                 record("play-furnace", "closed");
                 step++;
@@ -816,6 +842,11 @@ public final class VanillaProtocolClient {
         record("error", "timed out in play, step " + step + ", chunks " + chunks.size());
     }
 
+    /** The server answered the step's command or click (at least 1.5 s after it, as before), or had all the time. */
+    private static boolean answered(int count, int before, long sent, long now) {
+        return now - sent > 1500 && (count > before || now - sent > PATIENCE);
+    }
+
     /**
      * A right click's snowballs are counted: once the first came and a second could have come with it
      * (the server spawns each in the tick it handles the click), or once the server had all the time.
@@ -857,8 +888,12 @@ public final class VanillaProtocolClient {
      * packets (time, keep-alive, chunk data and light, whose batching follows each server's
      * timing) left out; null to skip it.
      */
-    private String respawnLine(Received r) {
+    private String respawnLine(Received r, int playerId) {
         String t = r.type;
+        // Other entities (a squid's swim event, a mob coming into view) land in the window as each server's
+        // ticks fall: only the player's own are PlayerList.respawn's.
+        Integer entity = entityOf(r.packet);
+        if (entity != null && entity != playerId) return null;
         // Entities moving, blocks the world's ticks change (a lava fall flows again once the game
         // runs) and the dead player's health land in the window between the death and the respawn
         // as each server's ticks fall: left out.
@@ -891,6 +926,21 @@ public final class VanillaProtocolClient {
         return t;
     }
 
+    /** The entity a packet is about, for the packets that name one; null for the rest. */
+    private static Integer entityOf(Packet<?> packet) {
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundAddEntityPacket p) return p.getId();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundUpdateAttributesPacket p) return p.getEntityId();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundEntityEventPacket p) return (int) field(p, "entityId");
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket p) return p.getEntity();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundAnimatePacket p) return p.getId();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundHurtAnimationPacket p) return p.id();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundDamageEventPacket p) return p.entityId();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundUpdateMobEffectPacket p) return p.getEntityId();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundRemoveMobEffectPacket p) return p.entityId();
+        if (packet instanceof net.minecraft.network.protocol.game.ClientboundSoundEntityPacket p) return p.getId();
+        return null;
+    }
+
     /**
      * A chunk's blocks, biomes, heightmaps and block entities (its
      * ClientboundLevelChunkPacketData bytes). The light is left out: both servers relight around chunks
diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRecipeBookOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRecipeBookOracle.java
index 60640010b..2cf9d7d48 100644
--- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRecipeBookOracle.java
+++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaRecipeBookOracle.java
@@ -1,12 +1,15 @@
 package dev.horizonlab.parity;
 
 import com.google.gson.*;
+import io.netty.buffer.Unpooled;
 import java.io.PrintWriter;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.*;
 import java.util.*;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.nbt.*;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.protocol.game.ServerboundRecipeBookChangeSettingsPacket;
 import net.minecraft.resources.Identifier;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.server.level.ServerPlayer;
@@ -102,8 +105,22 @@ public final class VanillaRecipeBookOracle {
                                 count = kind.equals("give") ? book.addRecipes(holders, player) : book.removeRecipes(holders, player);
                             }
                             case "seen" -> book.removeHighlight(key(op.get("id").getAsString()));
-                            case "set" -> book.setBookSetting(RecipeBookType.valueOf(op.get("type").getAsString()),
-                                op.get("open").getAsBoolean(), op.get("filtering").getAsBoolean());
+                            case "set" -> {
+                                var packet = new ServerboundRecipeBookChangeSettingsPacket(
+                                    RecipeBookType.valueOf(op.get("type").getAsString()),
+                                    op.get("open").getAsBoolean(), op.get("filtering").getAsBoolean());
+                                var buf = new FriendlyByteBuf(Unpooled.buffer());
+                                try {
+                                    ServerboundRecipeBookChangeSettingsPacket.STREAM_CODEC.encode(buf, packet);
+                                    byte[] wire = new byte[buf.readableBytes()];
+                                    buf.getBytes(buf.readerIndex(), wire);
+                                    extra = " packet=" + HexFormat.of().formatHex(wire);
+                                    var decoded = ServerboundRecipeBookChangeSettingsPacket.STREAM_CODEC.decode(buf);
+                                    book.setBookSetting(decoded.getBookType(), decoded.isOpen(), decoded.isFiltering());
+                                } finally {
+                                    buf.release();
+                                }
+                            }
                             case "save" -> {
                                 saved = (CompoundTag) ServerRecipeBook.Packed.CODEC.encodeStart(NbtOps.INSTANCE, book.pack()).getOrThrow();
                                 extra = compound(saved);
diff --git a/mods/official/far-view/Cargo.toml b/mods/official/far-view/Cargo.toml
new file mode 100644
index 000000000..965ee0bb4
--- /dev/null
+++ b/mods/official/far-view/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "far-view"
+version = "1.0.0"
+edition.workspace = true
+license.workspace = true
+publish = false
+description = "Horizon's official far view: distant terrain past the render distance."
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+horizon-mod-sdk = { path = "../../../crates/horizon-mod-sdk" }
+
+[lints]
+workspace = true
diff --git a/mods/official/far-view/horizon-mod.toml b/mods/official/far-view/horizon-mod.toml
new file mode 100644
index 000000000..5070f897c
--- /dev/null
+++ b/mods/official/far-view/horizon-mod.toml
@@ -0,0 +1,9 @@
+id = "far_view"
+name = "Far View"
+version = "1.0.0"
+description = "See much farther: the world past your render distance drawn as simplified distant terrain, out to 1024 chunks, without loading or simulating more chunks."
+authors = ["Horizon"]
+api = "0.1"
+side = "client"
+capabilities = ["render", "ui", "storage"]
+experimental = ["render", "ui"]
diff --git a/mods/official/far-view/src/lib.rs b/mods/official/far-view/src/lib.rs
new file mode 100644
index 000000000..e5b92e590
--- /dev/null
+++ b/mods/official/far-view/src/lib.rs
@@ -0,0 +1,89 @@
+//! Horizon's official far view: the world past the render distance drawn as
+//! distant terrain (`render.set-far-terrain`; the game builds the tiles on
+//! its own workers). Its settings page picks how far it reaches and the far
+//! tiles' detail, kept in the mod's storage (`distance`, `detail`). The
+//! player's own LOD Distance setting, when on, wins over the mod.
+use horizon_mod_sdk::{
+    Mod, Registration,
+    render::{self, FarTerrain},
+    storage,
+    ui::{self, ButtonWidget, Widget},
+};
+
+/// Distances in chunks, as LOD Distance offers them.
+const DISTANCES: [u32; 5] = [64, 128, 256, 512, 1024];
+/// Settings page buttons.
+const DISTANCE_BUTTON: u32 = 1;
+const DETAIL_BUTTON: u32 = 2;
+
+/// An index into [`DISTANCES`] and Far Detail's Reduced.
+struct FarView {
+    distance: usize,
+    reduced: bool,
+}
+
+impl FarView {
+    fn show(&self) {
+        render::set_far_terrain(Some(FarTerrain {
+            distance: DISTANCES[self.distance],
+            reduced: self.reduced,
+        }));
+    }
+    fn page(&self) {
+        let button = |id, label: String| Widget::Button(ButtonWidget { id, label });
+        ui::set_settings(&[
+            button(
+                DISTANCE_BUTTON,
+                format!("Distance: {} chunks", DISTANCES[self.distance]),
+            ),
+            button(
+                DETAIL_BUTTON,
+                format!(
+                    "Far detail: {}",
+                    if self.reduced { "Reduced" } else { "Full" }
+                ),
+            ),
+        ]);
+    }
+    fn save(&self) {
+        let _ = storage::set("distance", DISTANCES[self.distance].to_string().as_bytes());
+        let _ = storage::set("detail", if self.reduced { b"reduced" } else { b"full" });
+    }
+}
+
+fn stored(key: &str) -> Option<String> {
+    storage::get(key)
+        .and_then(|v| String::from_utf8(v).ok())
+        .map(|v| v.trim().to_owned())
+}
+
+impl Mod for FarView {
+    fn init() -> Result<(Self, Registration), String> {
+        // 256 chunks and full detail, as the docs suggest; an unknown value
+        // keeps the default.
+        let far = FarView {
+            distance: stored("distance")
+                .and_then(|v| DISTANCES.iter().position(|d| d.to_string() == v))
+                .unwrap_or(2),
+            reduced: stored("detail").as_deref() == Some("reduced"),
+        };
+        far.show();
+        far.page();
+        Ok((far, Registration::new()))
+    }
+    fn ui_select(&mut self, id: u32, _row: u32) {
+        match id {
+            DISTANCE_BUTTON => self.distance = (self.distance + 1) % DISTANCES.len(),
+            DETAIL_BUTTON => self.reduced = !self.reduced,
+            _ => return,
+        }
+        self.save();
+        self.show();
+        self.page();
+    }
+    fn ui_settings_opened(&mut self) {
+        self.page();
+    }
+}
+
+horizon_mod_sdk::export_mod!(FarView);
diff --git a/mods/official/recipes/Cargo.toml b/mods/official/recipes/Cargo.toml
new file mode 100644
index 000000000..5bf0f5d9c
--- /dev/null
+++ b/mods/official/recipes/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "recipes"
+version = "1.0.0"
+edition.workspace = true
+license.workspace = true
+publish = false
+description = "Horizon's official recipe viewer: every item beside the inventory, its recipes and uses."
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+horizon-mod-sdk = { path = "../../../crates/horizon-mod-sdk" }
+
+[lints]
+workspace = true
diff --git a/mods/official/recipes/horizon-mod.toml b/mods/official/recipes/horizon-mod.toml
new file mode 100644
index 000000000..f4c04af0d
--- /dev/null
+++ b/mods/official/recipes/horizon-mod.toml
@@ -0,0 +1,9 @@
+id = "recipes"
+name = "Recipes"
+version = "1.0.0"
+description = "Every item beside your inventory, with a search box. R over an item shows its recipes, U its uses (both rebindable in Controls), and + fills the crafting grid with a recipe you know. In creative mode a click can give you the item (Mod settings). On servers that are not Horizon, it shows this game's own 26.3 recipes; what you know and what + can fill follow the server's recipe book."
+authors = ["Horizon"]
+api = "0.1"
+side = "client"
+capabilities = ["recipes", "ui", "input", "game-read", "chat", "storage"]
+experimental = ["recipes", "ui", "input"]
diff --git a/mods/official/recipes/src/lib.rs b/mods/official/recipes/src/lib.rs
new file mode 100644
index 000000000..42f856016
--- /dev/null
+++ b/mods/official/recipes/src/lib.rs
@@ -0,0 +1,364 @@
+//! Horizon's official recipe viewer. Every item sits in the item panel the
+//! game draws beside the inventory and container screens (`browser`), with
+//! a search box. R over an item, the panel's or any slot's, shows its
+//! recipes, U its uses (`input.register-key`, so both can be rebound in
+//! Controls); a click does the same, left for recipes and right for uses.
+//! A recipe page has a tab per station, and + beside a crafting recipe the
+//! player knows fills the grid as the recipe book does (`recipes.place`).
+//! In creative mode, with "Click gives items" on, a click on a panel item
+//! gives one, a right click a stack (`recipes.give`).
+//!
+//! On a server that is not Horizon the recipes are the game's own 26.3
+//! ones; `known` and `place` follow the server's recipe book.
+use horizon_mod_sdk::{
+    Mod, Registration, browser, chat, game, input, recipes,
+    recipes::Kind,
+    storage,
+    ui::{self, ButtonWidget, Widget},
+};
+
+const RECIPE_KEY: &str = "recipe";
+const USES_KEY: &str = "uses";
+const GIVE_BUTTON: u32 = 1;
+/// What `set-recipes` takes at most.
+const MAX_RECIPES: usize = 256;
+const MAX_STACKS: usize = 64;
+/// The stations, in the order of their tabs, with each one's icon.
+const STATIONS: [&str; 8] = [
+    "minecraft:crafting_table",
+    "minecraft:furnace",
+    "minecraft:blast_furnace",
+    "minecraft:smoker",
+    "minecraft:campfire",
+    "minecraft:stonecutter",
+    "minecraft:smithing_table",
+    "minecraft:brewing_stand",
+];
+
+fn station(kind: Kind) -> usize {
+    match kind {
+        Kind::CraftingShaped | Kind::CraftingShapeless => 0,
+        Kind::Smelting => 1,
+        Kind::Blasting => 2,
+        Kind::Smoking => 3,
+        Kind::Campfire => 4,
+        Kind::Stonecutting => 5,
+        Kind::Smithing => 6,
+        Kind::Brewing => 7,
+    }
+}
+
+fn stack(item: &str) -> browser::Stack {
+    browser::Stack {
+        item: item.into(),
+        count: 1,
+        components: String::new(),
+    }
+}
+
+/// A recipe page: an item's recipes or its uses, on one station's tab.
+#[derive(Clone)]
+struct View {
+    item: browser::Stack,
+    uses: bool,
+    tab: usize,
+}
+
+#[derive(Default)]
+struct Recipes {
+    items: Vec<recipes::Item>,
+    all: Vec<recipes::Recipe>,
+    /// The panel's items now: indexes into `items`, after the search.
+    listed: Vec<usize>,
+    search: String,
+    /// The page shown, then the ones Back returns to.
+    history: Vec<View>,
+    /// The book id behind each recipe the page shows (-1: none).
+    shown: Vec<i32>,
+    give: bool,
+}
+
+impl Recipes {
+    fn id(&self, s: &recipes::Stack) -> &str {
+        self.items
+            .get(s.item as usize)
+            .map_or("minecraft:air", |i| &i.id)
+    }
+    fn convert(&self, s: &recipes::Stack) -> browser::Stack {
+        browser::Stack {
+            item: self.id(s).into(),
+            count: s.count,
+            components: s.components.clone(),
+        }
+    }
+    /// The same item, and the same components when `want` names some.
+    fn matches(&self, s: &recipes::Stack, want: &browser::Stack) -> bool {
+        self.id(s) == want.item && (want.components.is_empty() || s.components == want.components)
+    }
+    fn name<'a>(&'a self, item: &'a str) -> &'a str {
+        self.items
+            .iter()
+            .find(|i| i.id == item)
+            .map_or(item, |i| &i.name)
+    }
+
+    /// Loads the tables once a world is open, and drops them when it closes.
+    fn load(&mut self) {
+        let in_world = game::get_player().is_some();
+        if in_world && self.items.is_empty() {
+            self.items = recipes::items();
+            self.all = recipes::all();
+            self.list();
+        } else if !in_world && !self.items.is_empty() {
+            browser::set_recipes("", &[], 0, &[]);
+            browser::set_items(&[]);
+            *self = Recipes {
+                give: self.give,
+                ..Recipes::default()
+            };
+        }
+    }
+
+    /// Fills the panel with the items the search keeps: every word must be
+    /// in the name or the id; `@minecraft` keeps a namespace, `#logs` a tag.
+    fn list(&mut self) {
+        let words: Vec<String> = self
+            .search
+            .to_lowercase()
+            .split_whitespace()
+            .map(String::from)
+            .collect();
+        let keeps = |item: &recipes::Item| {
+            words.iter().all(|w| {
+                if let Some(ns) = w.strip_prefix('@') {
+                    item.id.split(':').next().is_some_and(|n| n.starts_with(ns))
+                } else if let Some(tag) = w.strip_prefix('#') {
+                    item.tags.iter().any(|t| t.contains(tag))
+                } else {
+                    item.name.to_lowercase().contains(w.as_str()) || item.id.contains(w.as_str())
+                }
+            })
+        };
+        self.listed = (self.items.iter().enumerate())
+            .filter(|(_, i)| i.id != "minecraft:air" && keeps(i))
+            .map(|(n, _)| n)
+            .collect();
+        let stacks: Vec<_> = self
+            .listed
+            .iter()
+            .map(|&n| stack(&self.items[n].id))
+            .collect();
+        browser::set_items(&stacks);
+    }
+
+    /// The recipes a view lists, all stations together.
+    fn found(&self, view: &View) -> Vec<&recipes::Recipe> {
+        (self.all.iter())
+            .filter(|r| {
+                if view.uses {
+                    r.slots
+                        .iter()
+                        .flatten()
+                        .any(|s| self.matches(s, &view.item))
+                } else {
+                    r.results.iter().any(|s| self.matches(s, &view.item))
+                }
+            })
+            .collect()
+    }
+
+    /// Opens a page, pushing it on the history; nothing when it is empty.
+    fn open(&mut self, item: browser::Stack, uses: bool) {
+        let view = View { item, uses, tab: 0 };
+        if self.found(&view).is_empty() {
+            return;
+        }
+        self.history.push(view);
+        self.show();
+    }
+
+    /// Sends the page on top of the history, or the items when there is none.
+    fn show(&mut self) {
+        let Some(mut view) = self.history.last().cloned() else {
+            self.shown.clear();
+            browser::set_recipes("", &[], 0, &[]);
+            return;
+        };
+        let found = self.found(&view);
+        let stations: Vec<usize> = (0..STATIONS.len())
+            .filter(|&s| found.iter().any(|r| station(r.kind) == s))
+            .collect();
+        view.tab = view.tab.min(stations.len().saturating_sub(1));
+        let on: Vec<&recipes::Recipe> = (found.iter().copied())
+            .filter(|r| stations.get(view.tab) == Some(&station(r.kind)))
+            .take(MAX_RECIPES)
+            .collect();
+        let known = recipes::known();
+        let views: Vec<browser::RecipeView> = on.iter().map(|r| self.view(r, &known)).collect();
+        let mut title = format!(
+            "{}: {}",
+            if view.uses { "Uses" } else { "Recipes" },
+            self.name(&view.item.item)
+        );
+        let total = found
+            .iter()
+            .filter(|r| stations.get(view.tab) == Some(&station(r.kind)))
+            .count();
+        if total > on.len() {
+            title.push_str(&format!(" ({} of {total})", on.len()));
+        }
+        let tabs: Vec<_> = stations.iter().map(|&s| stack(STATIONS[s])).collect();
+        browser::set_recipes(&title, &tabs, view.tab as u32, &views);
+        self.shown = on.iter().map(|r| r.book_id).collect();
+        if let Some(top) = self.history.last_mut() {
+            top.tab = view.tab;
+        }
+    }
+
+    fn view(&self, r: &recipes::Recipe, known: &[i32]) -> browser::RecipeView {
+        let mut slots: Vec<Vec<browser::Stack>> = (r.slots.iter())
+            .map(|s| s.iter().take(MAX_STACKS).map(|s| self.convert(s)).collect())
+            .collect();
+        let results = r
+            .results
+            .iter()
+            .take(MAX_STACKS)
+            .map(|s| self.convert(s))
+            .collect();
+        let (layout, width, height, note) = match r.kind {
+            Kind::CraftingShaped => (browser::Layout::Grid, r.width, r.height, String::new()),
+            Kind::CraftingShapeless => {
+                let n = slots.len() as u32;
+                let width = match n {
+                    0 | 1 => 1,
+                    2..=4 => 2,
+                    _ => 3,
+                };
+                let height = n.div_ceil(width).max(1);
+                slots.resize((width * height) as usize, Vec::new());
+                (browser::Layout::Grid, width, height, "Shapeless".into())
+            }
+            Kind::Smelting | Kind::Blasting | Kind::Smoking | Kind::Campfire => {
+                let seconds = r.cooking_time as f32 / 20.0;
+                let note = format!("{seconds} s, {} XP", (r.experience * 100.0).round() / 100.0);
+                (browser::Layout::Cooking, 1, 1, note)
+            }
+            Kind::Stonecutting => (browser::Layout::Single, 1, 1, String::new()),
+            Kind::Smithing => (browser::Layout::Smithing, 3, 1, String::new()),
+            Kind::Brewing => (browser::Layout::Brewing, 2, 1, String::new()),
+        };
+        // + only for what the recipe book shows; greyed until the book has it.
+        let action = (r.book_id >= 0).then(|| known.contains(&r.book_id));
+        browser::RecipeView {
+            layout,
+            width,
+            height,
+            slots,
+            results,
+            note,
+            action,
+        }
+    }
+
+    fn handle(&mut self, event: browser::Event) {
+        match event {
+            browser::Event::Search(text) => {
+                self.search = text;
+                self.list();
+            }
+            browser::Event::Clicked(c) => {
+                let Some(&n) = self.listed.get(c.index as usize) else {
+                    return;
+                };
+                let item = self.items[n].id.clone();
+                if self.give {
+                    let count = if c.right { 99 } else { 1 };
+                    let gift = recipes::Stack {
+                        item: n as u32,
+                        count,
+                        components: String::new(),
+                    };
+                    if recipes::give(&gift).is_ok() {
+                        return;
+                    }
+                }
+                self.open(stack(&item), c.right);
+            }
+            browser::Event::Key(k) if k.key == RECIPE_KEY || k.key == USES_KEY => {
+                let item = browser::Stack {
+                    count: 1,
+                    ..k.stack
+                };
+                self.open(item, k.key == USES_KEY);
+            }
+            browser::Event::SlotClicked(c) => {
+                let item = browser::Stack {
+                    count: 1,
+                    ..c.stack
+                };
+                self.open(item, c.right);
+            }
+            browser::Event::Tab(i) => {
+                if let Some(top) = self.history.last_mut() {
+                    top.tab = i as usize;
+                }
+                self.show();
+            }
+            browser::Event::Action(i) => {
+                let book = self.shown.get(i as usize).copied();
+                if let Some(Err(e)) = book.map(|b| recipes::place(b, false)) {
+                    chat::show(&e);
+                }
+            }
+            browser::Event::Back => {
+                self.history.pop();
+                self.show();
+            }
+            _ => {}
+        }
+    }
+
+    fn page(&self) {
+        ui::set_settings(&[Widget::Button(ButtonWidget {
+            id: GIVE_BUTTON,
+            label: format!(
+                "Click gives items (creative): {}",
+                if self.give { "ON" } else { "OFF" }
+            ),
+        })]);
+    }
+}
+
+impl Mod for Recipes {
+    fn init() -> Result<(Self, Registration), String> {
+        input::register_key(RECIPE_KEY, "Show recipes", "key.keyboard.r")?;
+        input::register_key(USES_KEY, "Show uses", "key.keyboard.u")?;
+        let give = storage::get("give").is_some_and(|v| v == b"true");
+        let me = Recipes {
+            give,
+            ..Recipes::default()
+        };
+        me.page();
+        Ok((me, Registration::new().on_frame()))
+    }
+    fn frame(&mut self, _seconds: f32) {
+        self.load();
+        // The keys matter only over an item, which `browser` reports.
+        let _ = input::poll();
+        for event in browser::poll() {
+            self.handle(event);
+        }
+    }
+    fn ui_select(&mut self, id: u32, _row: u32) {
+        if id == GIVE_BUTTON {
+            self.give = !self.give;
+            let _ = storage::set("give", if self.give { b"true" } else { b"false" });
+            self.page();
+        }
+    }
+    fn ui_settings_opened(&mut self) {
+        self.page();
+    }
+}
+
+horizon_mod_sdk::export_mod!(Recipes);
diff --git a/tests/test_cushion_particles.py b/tests/test_cushion_particles.py
new file mode 100644
index 000000000..adfbf2e00
--- /dev/null
+++ b/tests/test_cushion_particles.py
@@ -0,0 +1,87 @@
+"""Cushion particles must reach clients even when the server has no sprite atlas."""
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+@unittest.skipUnless(shutil.which("rustc"), "requires Rust")
+class CushionParticlesTests(unittest.TestCase):
+    def test_headless_server_records_break_effect_before_sprite_lookup(self):
+        source = (ROOT / "crates/horizon-client/src/game/cushions.rs").read_text()
+        start = source.index("    fn cushion_break_particles(")
+        end = source.index("    /// `BlockAttachedEntity.tick`", start)
+        fixture = r'''
+#![allow(dead_code)]
+#[derive(Clone, Copy)]
+struct Vec3 { x: f64, y: f64, z: f64 }
+struct Cushion { position: Vec3 }
+impl Cushion { fn color_name(&self) -> &str { "blue" } }
+struct Registry;
+impl Registry {
+    fn default_state(&self, name: &str) -> Option<u32> {
+        assert_eq!(name, "minecraft:blue_wool"); Some(123)
+    }
+}
+struct Assets { registry: Registry }
+struct Pack { assets: Assets }
+struct Audio { capture: Option<()> }
+mod horizon_client { pub mod particles {
+    pub enum ParticleType { Block }
+    pub struct ParticleOptions;
+    impl ParticleOptions {
+        pub fn block(_: ParticleType, _: String, _: u32) -> Self { Self }
+    }
+} }
+#[derive(Default)]
+struct Particles { count: u32 }
+impl Particles {
+    fn send_particles(&mut self, _: &horizon_client::particles::ParticleOptions,
+        at: [f64; 3], spread: [f64; 3], speed: f64, count: u32) {
+        assert!((at[1] - (10.0 + 1.0/6.0)).abs() < 1e-12);
+        assert_eq!(spread, [0.25, 0.0625, 0.25]);
+        assert_eq!(speed, 0.05); assert_eq!(count, 10); self.count += count;
+    }
+}
+struct Game {
+    pack: Pack, audio: Audio, particles: Particles, headless: bool,
+    lan_cushion_breaks: Vec<(u32, [f64; 3])>,
+}
+impl Game {
+    fn particle_sprite(&self, _: u32, _: [i32; 3]) -> Option<(String, u32)> {
+        (!self.headless).then(|| ("block/blue_wool".into(), 0xffffff))
+    }
+METHOD
+}
+fn main() {
+    let cushion = Cushion { position: Vec3 { x: 1.5, y: 10.0, z: 2.5 } };
+    for headless in [true, false] {
+        for serving in [true, false] {
+            let mut game = Game {
+                pack: Pack { assets: Assets { registry: Registry } },
+                audio: Audio { capture: serving.then_some(()) },
+                particles: Particles::default(), headless, lan_cushion_breaks: vec![],
+            };
+            game.cushion_break_particles(&cushion);
+            assert_eq!(game.lan_cushion_breaks.len(), usize::from(serving));
+            if serving {
+                let (state, at) = game.lan_cushion_breaks[0];
+                assert_eq!(state, 123);
+                assert_eq!([at[0], at[2]], [1.5, 2.5]);
+                assert!((at[1] - (10.0 + 1.0/6.0)).abs() < 1e-12);
+            }
+            assert_eq!(game.particles.count, if headless { 0 } else { 10 });
+        }
+    }
+}
+'''.replace("METHOD", source[start:end])
+        with tempfile.TemporaryDirectory(prefix="cushion-particles-") as directory:
+            path = Path(directory)
+            (path / "main.rs").write_text(fixture)
+            subprocess.run(["rustc", "--edition=2024", str(path / "main.rs"), "-o", str(path / "probe")],
+                           check=True, capture_output=True, text=True)
+            result = subprocess.run([str(path / "probe")], capture_output=True, text=True)
+            self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
diff --git a/tests/test_parity_reach.py b/tests/test_parity_reach.py
index 07e3df9e3..0e20f9174 100644
--- a/tests/test_parity_reach.py
+++ b/tests/test_parity_reach.py
@@ -111,6 +111,26 @@ class ReachTests(unittest.TestCase):
         self.assertIn("crates/a/src/display.rs", full)
         self.assertTrue(graph.results)
 
+    def test_a_module_moved_to_a_new_crate_counts_through_its_reexport(self):
+        # used.rs moves to crate b after the harness was recorded; a re-exports it under its old path. Crate c is
+        # a dependency nothing reached names: its items stay out even where their names match.
+        (self.root / "crates/a/src/used.rs").unlink()
+        workspace(self.root, {
+            "crates/a/Cargo.toml": (self.root / "crates/a/Cargo.toml").read_text()
+            + '\n[dependencies]\nb = { path = "../b" }\nc = { path = "../c" }\n',
+            "crates/a/src/lib.rs": "pub use b::used;\npub mod unused;\nmod methods;\nmod display;\n",
+            "crates/b/Cargo.toml": '[package]\nname = "b"\n',
+            "crates/b/src/lib.rs": "pub mod used;\n",
+            "crates/b/src/used.rs": "pub struct Thing;\npub fn helper() -> u32 { 1 }\n",
+            "crates/c/Cargo.toml": '[package]\nname = "c"\n',
+            "crates/c/src/lib.rs": "pub fn helper() -> u32 { 3 }\n",
+        })
+        changed = {"crates/b/src/used.rs", "crates/c/src/lib.rs"}
+        self.assertEqual(parity_reach.unrecorded(self.root, self.dependencies, changed), changed)
+        kept = self.narrowed(changed=changed)
+        self.assertIn("crates/b/src/used.rs", kept)
+        self.assertNotIn("crates/c/src/lib.rs", kept)
+
     def test_unknown_probes_keep_everything(self):
         self.assertEqual(set(self.narrowed(artifacts=[])), set(self.dependencies))
         self.assertEqual(set(self.narrowed(artifacts=[["example", "missing", "release", ["-p", "a"], True]])),
diff --git a/tests/test_parity_runner.py b/tests/test_parity_runner.py
index 518f23ba4..fdc636a24 100644
--- a/tests/test_parity_runner.py
+++ b/tests/test_parity_runner.py
@@ -290,9 +290,6 @@ class OracleReuseTests(unittest.TestCase):
         self.assertEqual(self.output.read_text(), "b")
 
 
-if __name__ == "__main__":
-    unittest.main()
-
 
 class LargeOutputTests(unittest.TestCase):
     def test_a_pass_clears_only_its_own_directory(self):
@@ -323,3 +320,178 @@ class LargeOutputTests(unittest.TestCase):
                 listing.write_text(f"{own / 'server.txt'}\n{own / 'client.txt'}\n")
                 parity.clear_large_outputs("state_provider#2", trace)
             self.assertEqual(sorted(path.name for path in own.iterdir()), ["report.json", "server.txt"])
+
+
+class FakeExecutor:
+    """Runs nothing: each start of a harness takes the next status from its script, a list."""
+    name, dead, max_peak = "fake", False, None
+
+    def __init__(self):
+        self.started, self.finished = [], []
+
+    def free(self):
+        return 1
+
+    def accepts(self, name):
+        return True
+
+    def fits(self, expected, only_here=True):
+        return True
+
+    def start(self, label, script, reuse, expected, shard=None):
+        self.started.append((label, reuse))
+        self.finished.append((label, {"status": script.pop(0), "seconds": 1.0, "dependencies": []}))
+        return True
+
+    def poll(self):
+        finished, self.finished = self.finished, []
+        return finished
+
+
+class KnownFlakyTests(unittest.TestCase):
+    def run_harnesses(self, scripts, flaky, rounds=None):
+        executor = FakeExecutor()
+        state = {"harnesses": {name: {"status": "pass", "oracle_reuse": True} for name in scripts}}
+        with tempfile.TemporaryDirectory() as tmp, mock.patch.multiple(parity, STATE_DIR=Path(tmp), SHARED=Path(tmp)), \
+                mock.patch.object(parity, "save_state"), mock.patch.object(parity, "time") as clock:
+            clock.monotonic.return_value = 0.0
+            results, _ = parity.run(scripts, state, None, "env", [executor], True, rounds, flaky)
+        return results, executor.started
+
+    def test_a_known_flaky_failure_runs_once_more_from_scratch_and_says_so(self):
+        results, started = self.run_harnesses({"dedicated_server": ["fail", "pass"]}, {"dedicated_server": "timer"})
+        self.assertEqual(results["dedicated_server"]["status"], "pass")
+        self.assertEqual(results["dedicated_server"]["retried"], "known flaky")
+        # The first run reused oracle results; a known flaky harness doesn't lose that by flaking.
+        self.assertTrue(results["dedicated_server"]["oracle_reuse"])
+        self.assertEqual(started, [("dedicated_server", True), ("dedicated_server", False)])
+
+    def test_only_once(self):
+        results, started = self.run_harnesses({"dedicated_server": ["fail", "fail"]}, {"dedicated_server": "timer"})
+        self.assertEqual(results["dedicated_server"]["status"], "fail")
+        self.assertEqual(len(started), 2)
+
+    def test_other_harnesses_keep_only_the_reused_oracle_retry(self):
+        results, started = self.run_harnesses({"food": ["fail", "pass"]}, {"dedicated_server": "timer"})
+        self.assertEqual((results["food"]["status"], results["food"]["retried"]), ("pass", "reused oracle results"))
+        self.assertEqual(started, [("food", True), ("food", False)])
+        self.assertFalse(results["food"]["oracle_reuse"])
+
+    def test_repeated_runs_get_no_retry(self):
+        results, started = self.run_harnesses({"dedicated_server": ["pass", "fail"]}, {"dedicated_server": "timer"},
+                                              rounds={"dedicated_server": 2})
+        self.assertEqual((results["dedicated_server"]["status"], len(started)), ("fail", 2))
+
+    def test_retries_reach_the_job_summary(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            summary = Path(tmp) / "summary.md"
+            with mock.patch.dict(os.environ, {"GITHUB_STEP_SUMMARY": str(summary)}), \
+                    mock.patch("builtins.print"):
+                parity.report_retries({"dedicated_server": {"status": "pass", "retried": "known flaky"},
+                                       "food": {"status": "pass"}}, {"dedicated_server": "timer"})
+            text = summary.read_text()
+        self.assertIn("RETRIED dedicated_server: failed, then passed on its one retry (known flaky: timer", text)
+        self.assertNotIn("food", text)
+
+    def test_the_known_flaky_list_has_a_reason_per_harness(self):
+        flaky = parity.known_flaky(parity.host_config())
+        self.assertTrue(all(isinstance(reason, str) and len(reason) > 20 for reason in flaky.values()))
+        self.assertTrue(set(flaky) <= {parity.base_name(name) for name in parity.harnesses()})
+
+
+
+class SoloTests(unittest.TestCase):
+    """Harnesses driving game windows run alone on a small machine (playhorizon's 4-CPU runner)."""
+
+    def executor(self, running):
+        with tempfile.TemporaryDirectory() as tmp, mock.patch.object(parity, "STATE_DIR", Path(tmp)):
+            local = parity.LocalExecutor(4, 1 << 40, 60)
+        local.solo = {"remote_fireworks"}
+        local.running = {label: {} for label in running}
+        return local
+
+    def test_a_solo_harness_waits_for_an_empty_machine_and_then_holds_it(self):
+        busy = self.executor(["food"])
+        self.assertFalse(busy.accepts("remote_fireworks"))
+        self.assertTrue(busy.accepts("light"))
+        self.assertEqual(busy.free(), 3)
+        self.assertTrue(self.executor([]).accepts("remote_fireworks"))
+        alone = self.executor(["remote_fireworks~2"])
+        self.assertEqual(alone.free(), 0)
+
+    def test_only_small_machines_and_listed_harnesses(self):
+        config = {"solo": {"remote_fireworks": "two game windows"}}
+        with mock.patch.dict(os.environ, {"PARITY_SOLO": "1"}):
+            self.assertEqual(parity.solo_harnesses(config), {"remote_fireworks"})
+        with mock.patch.dict(os.environ, {"PARITY_SOLO": "0"}):
+            self.assertEqual(parity.solo_harnesses(config), set())
+        with mock.patch.dict(os.environ, {"PARITY_SOLO": ""}), mock.patch.object(parity, "SOLO_CPUS", 10 ** 6):
+            self.assertEqual(parity.solo_harnesses(config), {"remote_fireworks"})
+        solo = parity.host_config().get("solo", {})
+        self.assertTrue(solo and set(solo) <= {parity.base_name(name) for name in parity.harnesses()})
+
+
+if __name__ == "__main__":
+    unittest.main()
+
+
+class WorkspaceManifestTests(unittest.TestCase):
+    """A crate split's Cargo.toml and Cargo.lock changes don't select every harness; a dependency change still does."""
+    CLIENT = '[package]\nname = "horizon-client"\n\n[dependencies]\nserde = "1"\nwgpu = { version = "27", features = ["x"] }\n'
+    LOCK = ('version = 4\n\n[[package]]\nname = "horizon-client"\nversion = "0.1.0"\ndependencies = [\n "serde",\n]\n\n'
+            '[[package]]\nname = "serde"\nversion = "1.0.1"\nsource = "registry+https://github.com/rust-lang/crates.io-index"\n')
+
+    def verdict(self, base, head):
+        """base, head: {path: text or None}; the manifests workspace_only_manifests leaves out."""
+        with tempfile.TemporaryDirectory() as temp, \
+                mock.patch.object(parity, "ROOT", Path(temp)), \
+                mock.patch.object(parity, "git_show", lambda _base, path: base.get(path)):
+            for path, text in head.items():
+                if text is not None:
+                    Path(temp, path).parent.mkdir(parents=True, exist_ok=True)
+                    Path(temp, path).write_text(text)
+            return parity.workspace_only_manifests(set(head) | set(base), "base")
+
+    def test_a_crate_split_is_left_out(self):
+        command = '[package]\nname = "horizon-command"\n\n[dependencies]\nserde = "1"\nhorizon-core = { path = "../horizon-core" }\n'
+        client = self.CLIENT + 'horizon-command = { path = "../horizon-command" }\n'
+        lock = self.LOCK.replace('[[package]]\nname = "serde"', '[[package]]\nname = "horizon-command"\nversion = "0.1.0"\n\n'
+                                 '[[package]]\nname = "serde"')
+        base = {"Cargo.toml": '[workspace]\nmembers = ["crates/horizon-client"]\nresolver = "2"\n',
+                "crates/horizon-client/Cargo.toml": self.CLIENT, "Cargo.lock": self.LOCK}
+        head = {"Cargo.toml": '[workspace]\nmembers = ["crates/horizon-client", "crates/horizon-command"]\nresolver = "2"\n',
+                "crates/horizon-client/Cargo.toml": client, "crates/horizon-command/Cargo.toml": command, "Cargo.lock": lock}
+        self.assertEqual(self.verdict(base, head), set(head))
+
+    def test_a_dependency_change_still_counts(self):
+        base = {"crates/horizon-client/Cargo.toml": self.CLIENT, "Cargo.lock": self.LOCK}
+        bumped = {"crates/horizon-client/Cargo.toml": self.CLIENT, "Cargo.lock": self.LOCK.replace("1.0.1", "1.0.2")}
+        self.assertEqual(self.verdict(base, bumped), set())
+        feature = {"crates/horizon-client/Cargo.toml": self.CLIENT.replace('["x"]', '["x", "y"]')}
+        self.assertEqual(self.verdict({"crates/horizon-client/Cargo.toml": self.CLIENT}, feature), set())
+        resolver = {"Cargo.toml": '[workspace]\nmembers = ["a"]\nresolver = "3"\n'}
+        self.assertEqual(self.verdict({"Cargo.toml": '[workspace]\nmembers = ["a"]\nresolver = "2"\n'}, resolver), set())
+
+    def test_a_feature_of_a_workspace_crate_counts_through_its_sources(self):
+        items = '[package]\nname = "horizon-items"\n\n[features]\ntest-support = []\n'
+        client = self.CLIENT + '\n[dev-dependencies]\nhorizon-items = { path = "../horizon-items", features = ["test-support"] }\n'
+        head = {"crates/horizon-items/Cargo.toml": items, "crates/horizon-client/Cargo.toml": client,
+                "crates/horizon-items/src/lib.rs": '#[cfg(feature = "test-support")]\npub fn for_tests() {}\n'}
+        base = {"crates/horizon-client/Cargo.toml": self.CLIENT}
+        # The new crate's files are all changed, the code the feature gates with them.
+        self.assertEqual(self.verdict(base, head), {"crates/horizon-items/Cargo.toml", "crates/horizon-client/Cargo.toml"})
+        # Turning on a feature of a crate whose gated code didn't change selects as before.
+        world = '[package]\nname = "horizon-world"\n\n[features]\nextra = ["more"]\nmore = []\n'
+        with tempfile.TemporaryDirectory() as temp, mock.patch.object(parity, "ROOT", Path(temp)):
+            Path(temp, "crates/horizon-world/src").mkdir(parents=True)
+            Path(temp, "crates/horizon-world/Cargo.toml").write_text(world)
+            Path(temp, "crates/horizon-world/src/lib.rs").write_text('#[cfg(feature = "more")]\nfn x() {}\n')
+            self.assertFalse(parity.feature_sources_changed("horizon-world", "extra", {"crates/horizon-client/Cargo.toml"}))
+            self.assertTrue(parity.feature_sources_changed("horizon-world", "extra", {"crates/horizon-world/src/lib.rs"}))
+            self.assertFalse(parity.feature_sources_changed("horizon-nothing", "extra", set()))
+        # A feature that reaches an external package counts.
+        optional = {"crates/horizon-client/Cargo.toml": self.CLIENT + '\n[features]\nfast = ["wgpu/x"]\n'}
+        self.assertEqual(self.verdict({"crates/horizon-client/Cargo.toml": self.CLIENT}, optional), set())
+
+    def test_without_a_base_everything_counts(self):
+        self.assertEqual(parity.workspace_only_manifests({"Cargo.lock"}, None), set())
diff --git a/tests/test_pr_ready.py b/tests/test_pr_ready.py
index 0eab92fb0..ab17340d3 100644
--- a/tests/test_pr_ready.py
+++ b/tests/test_pr_ready.py
@@ -9,7 +9,8 @@ PACKAGES = {"horizon-core": "crates/horizon-core", "horizon-client": "crates/hor
             "horizon-theme": "crates/horizon-theme", "xtask": "xtask"}
 LIBRARIES = set(PACKAGES) - {"xtask"}
 DEPENDENCIES = {"horizon-client": {"horizon-core"}}
-MODS = " --features horizon-mods/runtime,horizon-mods/pack,horizon-client/mods"
+MODS = " --features horizon-client/mods,horizon-mods/pack"
+CLIPPY = pr_ready.CI_CLIPPY + " && " + pr_ready.CI_CLIPPY_SERVER
 
 
 def args(host="local", quick=False):
@@ -35,6 +36,9 @@ class PrReadyTests(unittest.TestCase):
         self.assertFalse(pr_ready.workspace_rust("crates/horizon-client/README.md"))
         self.assertFalse(pr_ready.workspace_rust("launcher/src/main.rs"))
         self.assertTrue(pr_ready.launcher_rust("launcher/src/main.rs"))
+        # CI's launcher job also runs for the root workspace's manifests and for its own check.
+        self.assertTrue(pr_ready.launcher_rust("Cargo.lock"))
+        self.assertTrue(pr_ready.launcher_rust("tools/ci/rust_changes.py"))
         self.assertTrue(pr_ready.launcher_rust("crates/horizon-prepare/src/lib.rs"))
         self.assertTrue(pr_ready.launcher_rust("crates/horizon-theme/src/lib.rs"))
         self.assertTrue(pr_ready.launcher_rust("crates/horizon-telemetry/src/lib.rs"))
@@ -46,24 +50,48 @@ class PrReadyTests(unittest.TestCase):
         with mock.patch.object(pr_ready, "affected_here", return_value=[]):
             steps = pr_ready.plan(args(quick=True), "origin/main", {"crates/horizon-client/src/game.rs"}, PACKAGES, LIBRARIES, DEPENDENCIES)
         by_name = {step.name: step for step in steps}
-        self.assertEqual(by_name["clippy"].command,
-                         "cargo clippy -p horizon-client --all-targets --locked -- -D warnings")
+        self.assertEqual(by_name["clippy"].command, CLIPPY)
         self.assertEqual(by_name["tests: horizon-client"].command,
-                         "cargo test --locked -p horizon-client --tests")
+                         "cargo test --locked -p horizon-client --features horizon-client/mods --tests")
         self.assertEqual(by_name["doc tests"].command, "cargo test --locked -p horizon-client --doc")
         self.assertIsNone(by_name["doc tests"].status)
 
+    def test_content_root_tests_run_only_when_what_they_load_changes(self):
+        def content_step(path):
+            with mock.patch.object(pr_ready, "affected_here", return_value=[]):
+                steps = pr_ready.plan(args(quick=True), "origin/main", {path}, PACKAGES, LIBRARIES, DEPENDENCIES)
+            return {step.name: step for step in steps}["content root tests"]
+        self.assertEqual(content_step("crates/horizon-client/src/game.rs").skip, "content root untouched")
+        for path in ["crates/horizon-client/src/mod_content.rs", "crates/horizon-client/src/mod_content_tests.rs",
+                     "crates/horizon-mods/src/content.rs", "crates/horizon-assets/src/lib.rs", "Cargo.lock"]:
+            with self.subTest(path=path):
+                step = content_step(path)
+                self.assertIsNone(step.skip)
+                self.assertEqual(step.command, pr_ready.CONTENT_ROOT_TESTS)
+
     def test_shared_rust_configuration_keeps_workspace_coverage(self):
         for path in sorted(pr_ready.ROOT_RUST | {".cargo/config.toml", "crates/unknown/src/lib.rs"}):
             with self.subTest(path=path), mock.patch.object(pr_ready, "affected_here", return_value=[]):
                 steps = pr_ready.plan(args(quick=True), "origin/main", {path}, PACKAGES, LIBRARIES, DEPENDENCIES)
                 by_name = {step.name: step for step in steps}
-                self.assertEqual(by_name["clippy"].command,
-                                 "cargo clippy --workspace" + MODS + " --all-targets --locked -- -D warnings")
+                self.assertEqual(by_name["clippy"].command, CLIPPY)
                 self.assertEqual(by_name["tests: workspace"].command,
                                  "cargo test --locked --workspace" + MODS + " --tests")
                 self.assertEqual(by_name["doc tests"].command, "cargo test --locked --workspace --doc")
 
+    def test_tests_get_the_features_ci_s_workspace_run_gives_them(self):
+        self.assertEqual(pr_ready.mod_features(["horizon-world"]), "")
+        self.assertEqual(pr_ready.mod_features(["horizon-client"]), " --features horizon-client/mods")
+        self.assertEqual(pr_ready.mod_features(["horizon-mods"]),
+                         " --features horizon-mods/runtime,horizon-mods/pack,horizon-mods/index")
+        self.assertEqual(pr_ready.mod_features(None), MODS)
+
+    def test_python_tests_always_run(self):
+        with mock.patch.object(pr_ready, "affected_here", return_value=[]):
+            steps = pr_ready.plan(args(quick=True), "origin/main", {"crates/horizon-core/src/lib.rs"},
+                                  PACKAGES, LIBRARIES, DEPENDENCIES)
+        self.assertIsNone({step.name: step for step in steps}["Python tests"].status)
+
     def test_non_rust_changes_skip_workspace_checks(self):
         for path in ("README.md", "tools/pr_ready.py", "launcher/src/main.rs"):
             with self.subTest(path=path), mock.patch.object(pr_ready, "affected_here", return_value=[]):
@@ -77,7 +105,7 @@ class PrReadyTests(unittest.TestCase):
             steps = pr_ready.plan(args(), "origin/main",
                                   {"crates/horizon-core/src/lib.rs", "crates/horizon-client/examples/probe.rs"}, PACKAGES, LIBRARIES, DEPENDENCIES)
         for step in steps:
-            if step.name in ("clippy", "tests: horizon-client, horizon-core", "doc tests"):
+            if step.name in ("tests: horizon-client, horizon-core", "doc tests"):
                 self.assertIn("-p horizon-client -p horizon-core", step.command)
                 self.assertIsNone(step.status)
 
@@ -94,15 +122,17 @@ class PrReadyTests(unittest.TestCase):
         by_name = {step.name: step for step in steps}
         self.assertEqual(by_name["doc tests"].command, "cargo test --locked -p horizon-core --doc")
 
-    def test_clippy_checks_transitive_consumers_but_tests_only_touched_crates(self):
-        packages = {name: f"crates/{name}" for name in ("core", "world", "client", "unrelated")}
-        dependencies = {"world": {"core"}, "client": {"world"}, "unrelated": set()}
+    def test_clippy_is_ci_s_and_the_server_build_when_the_game_is_affected(self):
+        packages = {name: f"crates/{name}" for name in ("core", "world", "horizon-client", "unrelated")}
+        dependencies = {"world": {"core"}, "horizon-client": {"world"}, "unrelated": set()}
         with mock.patch.object(pr_ready, "affected_here", return_value=[]):
             steps = pr_ready.plan(args(), "origin/main", {"crates/core/src/lib.rs"},
                                   packages, set(packages), dependencies)
+            unrelated = pr_ready.plan(args(), "origin/main", {"crates/unrelated/src/lib.rs"},
+                                      packages, set(packages), dependencies)
+        self.assertEqual({step.name: step for step in unrelated}["clippy"].command, pr_ready.CI_CLIPPY)
         by_name = {step.name: step for step in steps}
-        self.assertEqual(by_name["clippy"].command,
-                         "cargo clippy -p client -p core -p world --all-targets --locked -- -D warnings")
+        self.assertEqual(by_name["clippy"].command, CLIPPY)
         self.assertEqual(by_name["tests: core"].command, "cargo test --locked -p core --tests")
         self.assertEqual(by_name["doc tests"].command, "cargo test --locked -p core --doc")
 
diff --git a/tests/test_release_train.py b/tests/test_release_train.py
index ee1fbcae5..2ded0790a 100644
--- a/tests/test_release_train.py
+++ b/tests/test_release_train.py
@@ -240,10 +240,34 @@ class ReleaseTrainTests(unittest.TestCase):
     def test_known_issues_are_the_bullets_of_the_file(self):
         with tempfile.TemporaryDirectory() as temp:
             path = Path(temp, "known-issues.md")
-            path.write_text("# Known issues\n\nSome text.\n\n- One.\n- Two, with **bold**.\n  continued\n")
-            self.assertEqual(train.known_issues(path), ["- One.", "- Two, with **bold**."])
+            path.write_text("# Known issues\n\nSome text.\n\n- One.\n- Two, with **bold**.  \n"
+                            "  continued with `code`\n\tand a [link](https://example.com).  \n- Three.\n")
+            self.assertEqual(train.known_issues(path),
+                             ["- One.", "- Two, with **bold**. continued with `code` and a [link](https://example.com).",
+                              "- Three."])
             self.assertEqual(train.known_issues(Path(temp, "missing.md")), [])
 
+    def test_known_issues_do_not_include_unrelated_text(self):
+        with tempfile.TemporaryDirectory() as temp:
+            path = Path(temp, "known-issues.md")
+            for separator in ["\n", "  \n", "# Heading\n", "Some text.\n"]:
+                with self.subTest(separator=separator):
+                    path.write_text("  Intro.\n- One.\n  continued.\n" + separator + "  Not an issue.\n- Two.\n")
+                    self.assertEqual(train.known_issues(path), ["- One. continued.", "- Two."])
+            path.write_text("# Known issues\n\nNo issues.\n")
+            self.assertEqual(train.known_issues(path), [])
+            path.write_text("")
+            self.assertEqual(train.known_issues(path), [])
+
+    def test_notes_keep_the_wrapped_shaderpacks_issue(self):
+        with tempfile.TemporaryDirectory() as temp:
+            path = Path(temp, "known-issues.md")
+            path.write_text("- Shader packs have been removed for now. Packs in your\n"
+                            "  `shaderpacks` folder are left where they are.\n")
+            _, body = train.notes("game", "v0.2.70", [pr(1)], train.known_issues(path))
+            self.assertIn("### Known issues\n- Shader packs have been removed for now. Packs in your "
+                          "`shaderpacks` folder are left where they are.\n", body)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/test_remote_mining.py b/tests/test_remote_mining.py
index 9feb255fa..4c77f989d 100644
--- a/tests/test_remote_mining.py
+++ b/tests/test_remote_mining.py
@@ -90,6 +90,7 @@ impl Game {
     fn predict_break(&mut self, pos: [i32; 3], _: u32, _: i32) { self.world.broken.push(pos); }
     fn send(&mut self, S::PlayerAction(packet): S) { self.packets.push(packet); }
     fn crack_particle(&mut self, _: [i32; 3], _: u8, _: u32) {}
+    fn breaking_block_effects(&mut self, _: [i32; 3], _: u8, _: bool) {}
 METHOD
 }
 fn main() {
diff --git a/tests/test_remote_motion.py b/tests/test_remote_motion.py
index 3a6e28de5..5148c2c1b 100644
--- a/tests/test_remote_motion.py
+++ b/tests/test_remote_motion.py
@@ -35,7 +35,8 @@ impl End { fn remote_eye_motion(&mut self, _id: u32, _v: [f64; 3]) {} }
 #[derive(Default)]
 struct Game {
     mobs: Vec<Entity>, dropped: Vec<Entity>, falling: Vec<Entity>, tnts: Vec<Entity>,
-    creatures: Creatures, dragon_fireballs: Vec<Entity>, tridents: Vec<Entity>, remote: Option<Remote>,
+    creatures: Creatures, dragon_fireballs: Vec<Entity>, tridents: Vec<Entity>,
+    rockets: Vec<Entity>, remote: Option<Remote>,
     potions: Potions, end: End,
 }
 impl Game {
diff --git a/tools/bench_sprite_mips.py b/tools/bench_sprite_mips.py
index 68024d6d2..e2456e3e9 100644
--- a/tools/bench_sprite_mips.py
+++ b/tools/bench_sprite_mips.py
@@ -52,7 +52,9 @@ def main():
     baseline = subprocess.check_output(['git', 'show', '89b58991bbc02eb79b6965fc4ca56357fe2297d9:crates/horizon-client/src/gfx.rs'], cwd=ROOT, text=True)
     code += '\n' + function(baseline, 'animate_sprites').replace('fn animate_sprites(', 'fn reference_animate_sprites(', 1)
     if args.test:
-        code += '\n' + function(source, 'sprite_mipmap_limit')
+        # sprites.rs holds it since the gfx -> sprites cut; older refs kept it in gfx.rs.
+        code += '\n' + (function(source, 'sprite_mipmap_limit') if 'fn sprite_mipmap_limit' in source
+                         else 'use sprites::sprite_mipmap_limit;')
         code += '\n' + source[source.index('#[cfg(test)]\nmod sprite_upload_tests'):]
     modules = '\n'.join(f'#[path = {json.dumps(str(ROOT / "crates/horizon-client/src" / (name + ".rs")))}] mod {name};'
                         for name in ('mipmap', 'sprites', 'fast_hash'))
diff --git a/tools/ci/runner-gc.sh b/tools/ci/runner-gc.sh
index 0f4f1e4c2..7ccf69ff0 100755
--- a/tools/ci/runner-gc.sh
+++ b/tools/ci/runner-gc.sh
@@ -9,6 +9,10 @@
 #     the shared vanilla data) that nothing touched for STALE_DAYS go; a harness that runs again rebuilds its own.
 #     .local/parity-runner (run state, oracle cache) stays.
 #   - The shared prepared resources keep their KEEP_PREPARED newest preparations, only while no runner works.
+#   - Java processes harnesses left behind (vanilla servers, oracles) go once ORPHAN_HOURS old: those whose parent
+#     is gone (adopted by launchd, init or systemd --user) and whose command line names a runner's checkout or a
+#     worktree's .local/. A job cancelled while it ran left such servers for days (2026-10-26); tools/parity.py now
+#     stops its harnesses on SIGTERM, and this catches what it can't (SIGKILL, a harness run by hand).
 set -euo pipefail
 root=${RUNNERS:-$HOME/.actions-runners}
 max_kb=$(( ${MAX_TARGET_GB:-12} * 1024 * 1024 ))
@@ -42,6 +46,25 @@ for runner in "$root"/horizon "$root"/horizon-[0-9]*; do
   fi
 done
 
+# [[dd-]hh:]mm:ss, as ps prints a process's age, in minutes.
+minutes() {
+  local t=$1 d=0 h=0 m a b c
+  if [[ $t == *-* ]]; then d=${t%%-*}; t=${t#*-}; fi
+  IFS=: read -r a b c <<< "$t"
+  if [ -n "$c" ]; then h=$a m=$b; else m=$a; fi
+  echo $(( 10#$d * 1440 + 10#$h * 60 + 10#$m ))
+}
+orphan_min=$(( ${ORPHAN_HOURS:-3} * 60 ))
+ps -A -o pid=,ppid=,etime=,command= | while read -r pid ppid etime command; do
+  case "$command" in *java*) ;; *) continue ;; esac
+  case "$command" in *"$root"/*/_work/*|*/.claude/worktrees/*/.local/*|*/code/horizon/.local/*) ;; *) continue ;; esac
+  [ "$(minutes "$etime")" -ge "$orphan_min" ] || continue
+  if [ "$ppid" != 1 ]; then
+    case "$(ps -o command= -p "$ppid" 2>/dev/null)" in *"systemd --user"*) ;; *) continue ;; esac
+  fi
+  if kill "$pid" 2>/dev/null; then echo "orphaned java $pid ($etime old) stopped: ${command:0:160}"; fi
+done
+
 prepared="$root/horizon/_work/horizon/shared-local/prepared"
 if [ "$any_busy" = 0 ] && [ -d "$prepared" ] && mkdir "$prepared/.lock" 2>/dev/null; then
   trap 'rmdir "$prepared/.lock" 2>/dev/null || true' EXIT
diff --git a/tools/command_exec_corpus.py b/tools/command_exec_corpus.py
index d8f925ef0..9a86c44f7 100644
--- a/tools/command_exec_corpus.py
+++ b/tools/command_exec_corpus.py
@@ -327,6 +327,17 @@ def entities():
         cmd('/data get entity @e[tag=attr,limit=1] Health'),
         cmd('/attribute @e[tag=attr,limit=1] minecraft:attack_damage base get'),
         cmd('/kill @e[tag=attr]'),
+        # An End crystal is an entity of its own: a type selector finds it,
+        # reads it and kills it (#1531).
+        cmd('/summon minecraft:end_crystal 4.5 210 8.5'),
+        cmd('/execute if entity @e[type=minecraft:end_crystal]'),
+        cmd('/data get entity @e[type=minecraft:end_crystal,limit=1] Pos'),
+        cmd('/kill @e[type=minecraft:end_crystal]'),
+        cmd('/execute if entity @e[type=minecraft:end_crystal]'),
+        cmd('/summon minecraft:ender_dragon 4.5 210 8.5'),
+        cmd('/execute if entity @e[type=minecraft:ender_dragon]'),
+        cmd('/data get entity @e[type=minecraft:ender_dragon,limit=1] Pos'),
+        cmd('/kill @e[type=minecraft:ender_dragon]'),
         *setup('/kill @e[type=minecraft:armor_stand]'),
         {'op': 'tick', 'n': 25},
         cmd('/execute if entity @e[tag=h]'),
@@ -533,13 +544,21 @@ def execute():
 
 def levels():
     """A nether portal round trip: on the way back the Overworld's entities (the
-    pig left by `entities`) are found and a summon names what it summoned."""
+    pig left by `entities`) are found and a summon names what it summoned. An
+    unbounded selector also reaches the level the player is not in, while a
+    bounded one does not."""
     return [
         *setup('/fill 2 231 12 5 236 12 minecraft:obsidian', '/fill 3 232 12 4 235 12 minecraft:nether_portal[axis=x]',
-               '/tp @s 3.5 232 12.5 0 0'),
+               '/tp @s 3.5 232 12.5 0 0',
+               # A cow in the Overworld, in a chunk that stays loaded while the
+               # player is in the nether.
+               '/forceload add 0 0',
+               '/summon minecraft:cow 10.5 210 4.5 {NoAI:1b,NoGravity:1b,Tags:["remote_cow"]}'),
         {'op': 'portal'},
         {'op': 'settle'},
         cmd('/execute if dimension minecraft:the_nether run say through the portal'),
+        cmd('/data get entity @e[tag=remote_cow,limit=1] Pos'),
+        cmd('/data get entity @e[tag=remote_cow,distance=..128,limit=1] Pos'),
         {'op': 'portal'},
         {'op': 'settle'},
         cmd('/execute if dimension minecraft:overworld run say back through the portal'),
diff --git a/tools/generate_command_order.py b/tools/generate_command_order.py
index ab78b3ada..e7e1175ae 100644
--- a/tools/generate_command_order.py
+++ b/tools/generate_command_order.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Generate crates/horizon-client/src/command/vanilla_order.rs: the order of
+"""Generate crates/horizon-command/src/vanilla_order.rs: the order of
 the children of each node of vanilla's command tree where Horizon's tree
 registers them in a different order. Brigadier keeps children in
 registration order, and /help (smart usage) lists them that way.
@@ -19,7 +19,7 @@ def main():
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     parser.add_argument("vanilla", type=Path)
     parser.add_argument("rust", type=Path)
-    parser.add_argument("--out", type=Path, default=ROOT / "crates/horizon-client/src/command/vanilla_order.rs")
+    parser.add_argument("--out", type=Path, default=ROOT / "crates/horizon-command/src/vanilla_order.rs")
     args = parser.parse_args()
     vanilla = json.loads(args.vanilla.read_text())
     rust = json.loads(args.rust.read_text())
diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py
index ab3fcde1b..1a0b25a9d 100755
--- a/tools/lan_e2e.py
+++ b/tools/lan_e2e.py
@@ -14,6 +14,8 @@ address. The script then checks, from both sides, what a guest's game used to ge
              closes on both when the guest closes it; the host keeps playing with its mouse look (#687);
 - crafting:  the guest crafts planks in the inventory's 2x2 grid and opens a crafting table, which
              leaves the host's screen and mouse look alone;
+- spawned:   the host and a guest new to the world join on different spots (PlayerSpawnFinder), and the
+             guest opens a crafting table, a chest, a furnace and a stonecutter where it joined;
 - sign:      a sign the guest places doesn't open a sign editor on the host;
 - damage:    a guest in survival takes fall damage;
 - mobs:      with the host in creative, a zombie and a skeleton go for the guest and hurt them;
@@ -22,7 +24,7 @@ address. The script then checks, from both sides, what a guest's game used to ge
 - pvp:       the guest and the host hit each other with a sword; with the pvp game rule off, or on one
              team without friendly fire, nothing;
 - kills:     a pig the guest kills counts in the guest's killed statistic, not the host's (#484);
-
+- leave:     a guest who leaves has leave_game in their saved statistics, and again after the next leave;
 
 - arrows:    the guest and the host shoot each other with a bow; with the pvp game rule off, nothing (#484);
 - looks:     mobs look on both sides as the server has them (their synched data): a calf is a
@@ -112,6 +114,10 @@ address. The script then checks, from both sides, what a guest's game used to ge
               use to completion still consumes the item (#1293).
 - eating:    each side sees the other player eat: the item in use (LivingEntity's flags) on the
              player it draws, and no longer once the bread is eaten (#803);
+- eat_full:  holding right click with melon slices until the food bar is full: the guest's own
+             client eats each slice when the server says it is done (entity event 9,
+             USE_ITEM_COMPLETE), so no other bite starts; held on chorus fruit, both fruits are
+             eaten across its cooldown (#2471).
 - xp:        experience orbs 4 blocks away fly to the guest, show on the guest's screen and give the
              guest their points (not the host).
 - objects:   boats, minecarts, armor stands, item frames and paintings the host summons reach the
@@ -257,6 +263,8 @@ address. The script then checks, from both sides, what a guest's game used to ge
 - instant_digging: an instant survival break leaves no repeated stone hit sounds or stale server dig (#1908).
 - replant:   flowers and crops replanted after a short harvest click stay planted for both players;
              the server forgets the completed instant break (#1880).
+- dig_stop:  a block the client breaks at once (a creative break, a dead bush) leaves the
+             server no dig to keep: the block put back stays and no mining sound plays on (#1340, #1908).
 
 Each check is reported on its own (a failing one doesn't stop the others) and the screenshots of
 both sides go to --out (host-*.png, guest-*.png).
@@ -292,14 +300,14 @@ ROOT = Path(__file__).resolve().parents[1]
 GUEST_NAME = 'Guest'
 # Match normal single player; --in-frame is the comparison path.
 SERVER_THREAD = True
-CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp',
-          'arrows', 'kills', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles',
+CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'spawned', 'sign', 'damage', 'mobs', 'hazards', 'pvp',
+          'arrows', 'kills', 'leave', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles',
           'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing',
           'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push',
-          'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles',
+          'piston-push', 'piston-slime', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles',
           'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects',
           'portals', 'distance', 'growth', 'doors', 'flight', 'ladder', 'boats', 'minecarts', 'frames', 'hands',
-          'lightning', 'riding', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption',
+          'lightning', 'riding', 'occupied_horse', 'mounts', 'worldspawn', 'beds', 'shield', 'deathmining', 'contacts', 'absorption',
           'breath', 'lava', 'levels', 'drops', 'underwater', 'fireworks']
 
 
@@ -339,8 +347,9 @@ class Game:
     def wait(self, ticks):
         self.d('wait', ticks=ticks)
 
-    def script(self, lines):
-        """Keep tick-sensitive input in one ctl process, through the normal control commands."""
+    def script(self, lines, every=False):
+        """Keep tick-sensitive input in one ctl process, through the normal control commands. Returns the last
+        reply, or with every=True all of them in order."""
         result = subprocess.run(self.d.base + ['script'], input='\n'.join(lines) + '\n',
                                 cwd=self.work, env=self.d.env, capture_output=True, text=True,
                                 timeout=600)
@@ -348,7 +357,7 @@ class Game:
         ticks = [r['ticks'] for r in replies if 'ticks' in r]
         print(f'[{self.name}] script {lines} -> {replies[-1] if replies else result.stderr[:400]}; ticks={ticks}')
         assert result.returncode == 0 and replies and not any('error' in r for r in replies), result.stdout
-        return replies[-1]
+        return replies if every else replies[-1]
 
     def until(self, observe, predicate, ticks=100):
         """Wait for an observable answer, within the existing tick budget."""
@@ -554,6 +563,39 @@ def check_crafting(host, guest, out):
     return {'planks': planks, 'table': counts}
 
 
+def check_spawned(host, guest, out):
+    """Players new to a world don't share one spot: ServerPlayer.adjustSpawnLocation spreads them over the
+    respawn radius (PlayerSpawnFinder). Two players standing in each other target each other, so a guest
+    left in the host could open nothing it clicked. At its own spot, the guest opens a crafting table, a
+    chest, a furnace and a stonecutter."""
+    joined = {'host': [round(v, 2) for v in host.joined_at], 'guest': [round(v, 2) for v in guest.joined_at]}
+    apart = abs(joined['host'][0] - joined['guest'][0]) + abs(joined['host'][2] - joined['guest'][2]) >= 0.6
+    guest('command', command='gamemode survival')
+    for game in (host, guest):
+        x, y, z = game.joined_at
+        game('command', command=f'tp @s {x} {y} {z}')
+    guest.wait(20)
+    x, y, z = (int(v // 1) for v in pos_of(guest))
+    at = (x, y, z + 2)
+    grab(host)
+    opened = {}
+    for block in ('crafting_table', 'chest', 'furnace', 'stonecutter'):
+        guest('command', command=f'setblock {at[0]} {at[1]} {at[2]} minecraft:{block}')
+        guest.wait(10)
+        guest.raw('interact', *at)
+        guest.wait(10)
+        opened[block] = guest('state').get('screen')
+        guest.shot(out, f'spawned-{block}')
+        back_to_game(guest)
+        guest('command', command=f'setblock {at[0]} {at[1]} {at[2]} minecraft:air')
+    host_unaffected(host, "the guest's stations")
+    face_each_other(host, guest)
+    assert apart, f'the host and the guest joined on one spot: {joined}'
+    want = {'crafting_table': 'inventory', 'chest': 'container', 'furnace': 'container', 'stonecutter': 'station'}
+    assert opened == want, f'where it joined, the guest opened {opened}'
+    return {'joined': joined, 'opened': opened}
+
+
 def check_sign(host, guest, out):
     x, y, z = (int(v // 1) for v in pos_of(guest))
     spot = (x + 2, y, z)
@@ -1154,6 +1196,35 @@ def check_pvp(host, guest, out):
     return hits
 
 
+def leave_game_total(host):
+    """The leave_game statistic summed over the stats files the host's world holds."""
+    total = 0
+    for path in (host.work / 'saves' / 'Lan' / 'players' / 'stats').glob('*.json'):
+        custom = json.loads(path.read_text()).get('stats', {}).get('minecraft:custom', {})
+        total += custom.get('minecraft:leave_game', 0)
+    return total
+
+
+def check_leave(host, guest, out):
+    # PlayerList.remove awards Stats.LEAVE_GAME before it saves the player: a guest who leaves has it in
+    # their saved statistics, and it counts again the next time they leave.
+    port = host.raw('lan', 'status')['port']
+    before = leave_game_total(host)
+    counts = []
+    for _ in range(2):
+        guest.raw('disconnect')
+        for _ in range(20):
+            time.sleep(0.5)
+            if leave_game_total(host) > (counts[-1] if counts else before):
+                break
+        counts.append(leave_game_total(host))
+        guest.raw('connect', f'127.0.0.1:{port}', GUEST_NAME)
+        guest.raw('wait-for', 'loaded', '--timeout', 300)
+        guest.wait(20)
+    assert counts == [before + 1, before + 2], f'leave_game was {before}, then {counts} after two leaves'
+    return {'leave_game': counts}
+
+
 def check_kills(host, guest, out):
     # A mob the guest kills is the guest's kill (#484): LivingEntity.die credits lastHurtByPlayer, so the
     # killed statistic (and its scoreboard criterion) counts for the guest, not the host.
@@ -2368,6 +2439,168 @@ def wait_state(game, pos, key, want, ticks):
     return state_of(game, pos, key)
 
 
+def check_piston_push(host, guest, out):
+    """A moving piston pushes both players and a stationary mob on each host path."""
+    hx, _, hz = pos_of(host)
+    x, y, z = (int(hx // 16) * 16 + 8, 100, int(hz // 16) * 16 + 8)
+    host('command', command=f'fill {x-4} {y-1} {z-4} {x+7} {y-1} {z+4} minecraft:stone')
+    host('command', command=f'fill {x-4} {y} {z-4} {x+7} {y+5} {z+4} minecraft:air')
+    host('command', command=f'setblock {x} {y} {z} minecraft:piston[facing=east]')
+    results = {}
+    for player, name in ((host, host.player), (guest, GUEST_NAME)):
+        host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+        host.wait(10)
+        host('command', command=f'tp @s {x+5.5} {y} {z+2.5}')
+        host('command', command=f'tp {GUEST_NAME} {x+5.5} {y} {z-1.5}')
+        host('command', command=f'tp {"@s" if player is host else GUEST_NAME} {x+1.65} {y} {z+0.5}')
+        player.wait(15)
+        before = pos_of(player)
+        assert abs(before[0] - (x + 1.65)) < 0.1, f'{name} did not reach piston: {before}'
+        host('command', command=f'setblock {x-1} {y} {z} minecraft:redstone_block')
+        player.wait(30)
+        after = pos_of(player)
+        results[name] = after[0] - before[0]
+        assert results[name] > 0.3, f'piston did not push {name}: {before} -> {after}'
+    host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+    host.wait(10)
+    host('command', command=f'tp {GUEST_NAME} {x+5.5} {y} {z-1.5}')
+    host('command', command=f'tp @s {x+1.65} {y} {z+0.5}')
+    host.wait(10)
+    host.raw('key', 'e', 'tap')
+    host.raw('wait-for', 'screen', 'inventory')
+    before = pos_of(host)
+    guest('command', command=f'setblock {x-1} {y} {z} minecraft:redstone_block')
+    host.wait(30)
+    after = pos_of(host)
+    results['inventory'] = after[0] - before[0]
+    assert results['inventory'] > 0.3, f'piston did not push player with inventory open: {before} -> {after}'
+    host.raw('key', 'esc', 'tap')
+    host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+    host.wait(10)
+    host('command', command=f'tp @s {x+5.5} {y} {z+2.5}')
+    host('command', command=f'summon minecraft:pig {x+1.65} {y} {z+0.5} {{NoAI:1b}}')
+    host.wait(10)
+    pigs = host('entities', radius=16, type='pig')['entities']
+    pig = min(pigs, key=lambda p: abs(p['pos'][0] - (x + 1.65)) + abs(p['pos'][2] - (z + 0.5)))
+    before = pig['pos'][0]
+    host('command', command=f'setblock {x-1} {y} {z} minecraft:redstone_block')
+    host.wait(30)
+    pigs = host('entities', radius=16, type='pig')['entities']
+    after = next(p['pos'][0] for p in pigs if p['id'] == pig['id'])
+    results['pig'] = after - before
+    assert results['pig'] > 0.3, f'piston did not push pig: {before} -> {after}'
+    results.update(piston_push_at_border(host, guest))
+    return results
+
+
+def piston_push_at_border(host, guest):
+    """A piston next to the world border: the border's wall stops the pushed
+    body, as it stops ordinary movement (`Entity.collectCollidersIgnoringWorldBorder`)."""
+    hx, _, hz = pos_of(host)
+    x, y, z = (int(hx // 16) * 16 + 8, 100, int(hz // 16) * 16 + 8)
+    host('command', command=f'fill {x-4} {y-1} {z-4} {x+7} {y-1} {z+4} minecraft:stone')
+    host('command', command=f'fill {x-4} {y} {z-4} {x+7} {y+5} {z+4} minecraft:air')
+    host('command', command=f'setblock {x} {y} {z} minecraft:piston[facing=east]')
+    # The border's east wall stands at `x + 2`, the east face of the block the
+    # head extends into: a body pushed east stops there instead of being
+    # pushed out through the border. `worldborder center` centres integers on
+    # the block, so the centre is `x - 8.5` and the wall lands on `x + 2`.
+    wall = x + 2
+    center = [x - 8.5, z + 0.5]
+    results = {}
+    try:
+        host('command', command=f'worldborder center {x - 9} {z}')
+        host('command', command='worldborder set 20.5')
+        seen = None
+        for _ in range(10):
+            host.wait(2)
+            seen = [g('status').get('border') for g in (host, guest)]
+            if all(b and b['size'] == 20.5 and b['center'] == center for b in seen):
+                break
+        results['border'] = seen
+        for player, name in ((host, host.player), (guest, GUEST_NAME)):
+            host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+            host.wait(10)
+            host('command', command=f'tp @s {x+5.5} {y} {z+2.5}')
+            host('command', command=f'tp {GUEST_NAME} {x+5.5} {y} {z-1.5}')
+            host('command', command=f'tp {"@s" if player is host else GUEST_NAME} {x+1.65} {y} {z+0.5}')
+            player.wait(15)
+            before = pos_of(player)
+            assert abs(before[0] - (x + 1.65)) < 0.1, f'{name} did not reach the piston: {before}'
+            host('command', command=f'setblock {x-1} {y} {z} minecraft:redstone_block')
+            player.wait(30)
+            after = pos_of(player)
+            # The wall's inner face is at `wall`: the body's box stops there.
+            results[name] = round(after[0] - before[0], 3)
+            assert after[0] > before[0], f'the piston did not push {name}: {before} -> {after}'
+            assert after[0] <= wall - 0.3 + 0.01, f'the border did not stop {name}: {before} -> {after}'
+        host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+        host.wait(10)
+    finally:
+        host('command', command='worldborder center 0 0')
+        host('command', command='worldborder set 59999968')
+    return results
+
+
+def check_piston_slime(host, guest, out):
+    """A piston pushing a slime block: the block pushes the body in front of
+    it and bounces it (`PistonMovingBlockEntity.moveCollidedEntities`)."""
+    hx, _, hz = pos_of(host)
+    x, y, z = (int(hx // 16) * 16 + 8, 100, int(hz // 16) * 16 + 8)
+    results = {}
+
+    def setup():
+        # The previous case may have left a mob where the body stands.
+        host('command', command='kill @e[type=minecraft:pig]')
+        host('command', command=f'setblock {x} {y} {z} minecraft:air')
+        host.wait(10)
+        host('command', command=f'fill {x-4} {y-1} {z-4} {x+7} {y-1} {z+4} minecraft:stone')
+        host('command', command=f'fill {x-4} {y} {z-4} {x+7} {y+5} {z+4} minecraft:air')
+        host('command', command=f'setblock {x} {y} {z} minecraft:piston[facing=east]')
+        host.wait(5)
+
+    for player, name in ((host, host.player), (guest, GUEST_NAME)):
+        setup()
+        host('command', command=f'setblock {x+1} {y} {z} minecraft:slime_block')
+        host('command', command=f'tp @s {x+5.5} {y} {z+2.5}')
+        host('command', command=f'tp {GUEST_NAME} {x+5.5} {y} {z-1.5}')
+        host('command', command=f'tp {"@s" if player is host else GUEST_NAME} {x+2.5} {y} {z+0.5}')
+        player.wait(15)
+        before = pos_of(player)
+        assert abs(before[0] - (x + 2.5)) < 0.1, f'{name} did not reach the slime: {before}'
+        host('command', command=f'setblock {x-1} {y} {z} minecraft:redstone_block')
+        # The bounce sets the velocity along the push axis; it decays fast, so
+        # sample it while the block is still moving.
+        speed = 0.0
+        for _ in range(6):
+            player.wait(2)
+            speed = max(speed, player('state')['player']['velocity'][0])
+        after = pos_of(player)
+        results[name] = round(after[0] - before[0], 3)
+        # The block pushes the body out of its way, and the bounce launches it.
+        assert results[name] > 1.5, f'the slime block did not push and bounce {name}: {before} -> {after}'
+        assert speed > 0.05, f'the slime block did not bounce {name}: {speed}'
+        host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+        player.wait(10)
+    # A plain block only pushes: the body is not launched.
+    setup()
+    host('command', command=f'setblock {x+1} {y} {z} minecraft:stone')
+    host('command', command=f'tp @s {x+2.5} {y} {z+0.5}')
+    host.wait(15)
+    before = pos_of(host)
+    host('command', command=f'setblock {x-1} {y} {z} minecraft:redstone_block')
+    speed = 0.0
+    for _ in range(6):
+        host.wait(2)
+        speed = max(speed, host('state')['player']['velocity'][0])
+    after = pos_of(host)
+    results['stone'] = round(after[0] - before[0], 3)
+    assert results['stone'] < 1.5, f'a plain block bounced the player: {before} -> {after}'
+    host('command', command=f'setblock {x-1} {y} {z} minecraft:air')
+    host.wait(10)
+    return results
+
+
 def check_plates(host, guest, out):
     guest('command', command='gamemode survival')
     x, y, z = (int(v // 1) for v in pos_of(guest))
@@ -2935,13 +3168,15 @@ def check_fireworks(host, guest, out):
         game('command', command=f'tp @s {x + dx + 0.5} {y} {z + 0.5}')
         game.raw('look-at', x + 0.5, y + 1.5, z + 3.5)
 
-    def red(path):
+    def reds(path):
+        """The red pixels' positions, above the hotbar."""
         rows, bpp = png_rows(path)
-        # Exclude the hotbar and chat at the bottom of the view.
-        return sum(row[i] > 80 and row[i] > 2 * row[i + 1] and row[i] > 2 * row[i + 2]
-                   for row in rows[:len(rows) * 3 // 4] for i in range(0, len(row), bpp))
+        return {(y, i) for y, row in enumerate(rows[:len(rows) * 3 // 4]) for i in range(0, len(row), bpp)
+                if row[i] > 80 and row[i] > 2 * row[i + 1] and row[i] > 2 * row[i + 2]}
 
-    baseline = {g.name: red(g.shot(out, 'fireworks-before')) for g in (host, guest)}
+    # Red where the view had none: the setup's own red chat lines (a fill that changed nothing) are in the
+    # baseline, and fade out before the later shots, which a plain count difference would take as missing sparks.
+    baseline = {g.name: reds(g.shot(out, 'fireworks-before')) for g in (host, guest)}
     before = {g.name: made(g, 'flash') for g in (host, guest)}
     host('command', command='item replace entity @s weapon.mainhand with minecraft:firework_rocket'
          '[fireworks={flight_duration:0,explosions:[{shape:"large_ball",colors:[I;16711680],has_trail:true}]}]')
@@ -2954,12 +3189,14 @@ def check_fireworks(host, guest, out):
             break
     flashes = {g.name: made(g, 'flash') - before[g.name] for g in (host, guest)}
     assert all(n == 1 for n in flashes.values()), f'configured burst missing or duplicated: {flashes}'
-    # Capture both views before decoding PNGs: decoding must not consume the sparks' lifetime.
+    # Capture both views before decoding PNGs: decoding must not consume the sparks' lifetime (48-59 ticks). A
+    # screenshot takes ~0.6 s where the frame is drawn on the CPU (lavapipe), so the later shots come 4 ticks after
+    # the burst's, not more: by then the tracked rocket is gone.
     burst_shots = {g.name: g.shot(out, 'fireworks-burst') for g in (host, guest)}
-    host.wait(16)
+    host.wait(4)
     trail_shots = {g.name: g.shot(out, 'fireworks-trail-fade') for g in (host, guest)}
-    burst = {name: red(path) - baseline[name] for name, path in burst_shots.items()}
-    trails = {name: red(path) - baseline[name] for name, path in trail_shots.items()}
+    burst = {name: len(reds(path) - baseline[name]) for name, path in burst_shots.items()}
+    trails = {name: len(reds(path) - baseline[name]) for name, path in trail_shots.items()}
     rockets = {g.name: g('status')['rockets'] for g in (host, guest)}
     assert not any(rockets.values()), f'exploded rocket remains: {rockets}'
     assert all(n > 20 for n in burst.values()), f'no red burst: {burst}'
@@ -4199,6 +4436,49 @@ def check_riding(host, guest, out):
     return result
 
 
+def check_occupied_horse(host, guest, out):
+    """#1759: a mob passenger fills a zombie horse's seat, for both real players."""
+    spots = apart(host, guest)
+    result = {}
+    tag = 'occupied_horse'
+    host('command', command='time set midnight')
+    for label, player in (('host', host), ('guest', guest)):
+        x, y, z = spots[label]
+        at = (x + 0.5, y, z + 2.5)
+        player('command', command='gamemode creative')
+        player('command', command='clear @s')
+        result[label] = {}
+        for occupied in (True, False):
+            passengers = ',Passengers:[{id:"minecraft:zombie",NoAI:1b,PersistenceRequired:1b}]' if occupied else ''
+            try:
+                player('command', command=f'summon minecraft:zombie_horse {at[0]} {y} {at[2]} '
+                                         f'{{Tame:1b,NoAI:1b,NoGravity:1b,Tags:["{tag}"]{passengers}}}')
+                player.wait(5)
+                horse = next(m for m in player.raw('mobs', 16)['near']
+                             if m['kind'] == 'minecraft:zombie_horse' and m['health'] > 0
+                             and math.dist(m['pos'], at) < 0.1)
+                if occupied:
+                    # Assert the setup too: a missing passenger would make this a false positive.
+                    passengers_nbt = host('command', command=f'data get entity @e[tag={tag},limit=1] Passengers')
+                    assert 'minecraft:zombie' in json.dumps(passengers_nbt), passengers_nbt
+                player.raw('look-at', at[0], y + 0.8, at[2])
+                player.raw('mouse', 'right', 'click')
+                player.wait(10)
+                riding = player('status').get('riding')
+                expected = None if occupied else horse['id']
+                assert riding == expected, f'{label}: occupied={occupied}, riding={riding}, expected={expected}'
+                result[label]['occupied' if occupied else 'free'] = riding
+                player.shot(out, f'occupied-horse-{label}-{occupied}')
+                if not occupied:
+                    hold(player, 'shift', 5)
+            finally:
+                player('command', command=f'kill @e[tag={tag}]')
+                player('command', command=f'kill @e[type=minecraft:zombie,x={x},y={y},z={z},distance=..6]')
+                player('command', command=f'tp @s {x + 0.5} {y} {z + 0.5} 0 0')
+                player.wait(25)
+    return result
+
+
 # Mount inventories: (kind, summon NBT, what goes in by shift-click and the menu slot it lands
 # in: 700 the saddle, 701 the body armour or carpet, 710 the chest's first slot).
 MOUNT_MENUS = [
@@ -4669,6 +4949,7 @@ def check_worn(host, guest, out):
 
 CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour,
              'nametags': check_nametags, 'chest': check_chest, 'crafting': check_crafting,
+             'spawned': check_spawned,
              'sign': check_sign, 'damage': check_damage, 'mobs': check_mobs,
              'hazards': check_hazards, 'pvp': check_pvp, 'respawn': check_respawn,
              'containers': check_containers, 'feedback': check_feedback, 'titles': check_titles,
@@ -4679,16 +4960,17 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour,
              'cartography': check_cartography, 'hurt': check_hurt, 'commands': check_commands,
              'recipes': check_recipes, 'trials': check_trials, 'walls': check_walls,
              'effects': check_effects, 'portals': check_portals, 'distance': check_distance,
-             'clicks': check_clicks, 'sleep': check_sleep, 'push': check_push,
+             'clicks': check_clicks, 'sleep': check_sleep, 'push': check_push, 'piston-push': check_piston_push,
+             'piston-slime': check_piston_slime,
              'eat': check_eat, 'eating': check_eating, 'xp': check_xp,
              'objects': check_objects, 'projectiles': check_projectiles, 'blast': check_blast,
              'light': check_light, 'plates': check_plates, 'swings': check_swings,
              'cracks': check_cracks, 'time': check_time, 'growth': check_growth, 'doors': check_doors,
              'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect,
-             'barter': check_barter, 'worn': check_worn, 'kills': check_kills,
+             'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'leave': check_leave,
              'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder,
              'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'hands': check_hands,
-             'lightning': check_lightning, 'riding': check_riding, 'mounts': check_mounts,
+             'lightning': check_lightning, 'riding': check_riding, 'occupied_horse': check_occupied_horse, 'mounts': check_mounts,
              'worldspawn': check_world_spawn, 'beds': check_beds, 'shield': check_shield, 'deathmining': check_death_mining,
              'contacts': check_contacts, 'absorption': check_absorption, 'breath': check_breath,
              'lava': check_lava, 'levels': check_levels, 'drops': check_drops,
@@ -4707,9 +4989,17 @@ def run(ctl, out, resources, checks):
     host, guest = Game('host', ctl, resources), Game('guest', ctl, resources)
     # Either way explicitly: the game's default is the server thread.
     host.d.env['HORIZON_SERVER_THREAD'] = '1' if SERVER_THREAD else '0'
+    # A headless run (HORIZON_E2E_HEADLESS) has no focused window to draw in: the games render
+    # offscreen and never pause on the focus loss, or the world would stand still.
+    headless = bool(os.environ.get('HORIZON_E2E_HEADLESS'))
+    launch = ['launch']
+    if headless or sys.platform == 'darwin':
+        launch.append('--offscreen')
+    if headless:
+        launch.append('--no-pause')
     results = {}
     try:
-        host.pid = host('launch', wait=False, offscreen=sys.platform == 'darwin')['pid']
+        host.pid = host.raw(*launch)['pid']
         # Guests' commands need the world's Allow Commands as well as the LAN's (#372): a creative
         # world has them; everyone plays in survival.
         host.raw('open', 'Lan', 5, 'creative')
@@ -4723,10 +5013,12 @@ def run(ctl, out, resources, checks):
         host('command', command='gamerule spawn_mobs false')
         port = host.raw('lan', 'open', 0, 'commands')['port']
         host.player = host.raw('lan', 'status').get('host', 'Player')  # the host's profile name
-        guest.pid = guest('launch', wait=False, offscreen=sys.platform == 'darwin')['pid']
+        guest.pid = guest.raw(*launch)['pid']
         guest.raw('connect', f'127.0.0.1:{port}', GUEST_NAME)
         guest.raw('wait-for', 'loaded', '--timeout', 300)
         guest.wait(40)
+        # Where each joined, before anything moves them (check_spawned).
+        host.joined_at, guest.joined_at = pos_of(host), pos_of(guest)
         face_each_other(host, guest)
         host.shot(out, 'joined')
         guest.shot(out, 'joined')
@@ -5175,6 +5467,64 @@ CHECKS += ['helduse']
 CHECK_FNS.update(helduse=check_held_use)
 
 
+def check_eat_full(host, guest, out):
+    """Holding right click past a full food bar starts no other bite; chorus fruit's cooldown
+    doesn't leave the use stuck (#2471)."""
+    guest('command', command='gamemode survival')
+    guest('command', command='clear @s')
+    # Full health: natural regeneration at 18 food or more would eat into the bar.
+    guest('command', command='effect give @s minecraft:instant_health 1 10')
+    guest('command', command='effect give @s minecraft:hunger 60 127')
+    for _ in range(400):
+        if remote(guest)['food'] <= 17:
+            break
+        guest.wait(1)
+    guest('command', command='effect clear @s')
+    guest('command', command='give @s minecraft:melon_slice 16')
+    guest.wait(5)
+    guest.raw('select', 'minecraft:melon_slice')
+    hungry = remote(guest)['food']
+    # A slice (2 food) takes 32 ticks (1.6 s): the button stays down well past the slices that fill
+    # the bar, with room for a slow server.
+    slices = -(-(20 - hungry) // 2)
+    hold = threading.Thread(target=guest.raw, args=('use-item', '--hold', slices * 4.0 + 6.0))
+    hold.start()
+    deadline = time.monotonic() + slices * 4.0 + 2.0
+    while remote(guest)['food'] < 20 and time.monotonic() < deadline:
+        time.sleep(0.1)
+    # The bar is full and the button is still down: nothing is in use over the next 20 ticks
+    # (sleeps, as `wait` is refused while the held use-item runs).
+    using = []
+    for _ in range(4):
+        time.sleep(0.25)
+        using.append(guest('state').get('using'))
+    guest.shot(out, 'eat-full')
+    hold.join()
+    guest.wait(10)
+    full = {'hungry': hungry, 'fed': remote(guest)['food'], 'using': using,
+            'eaten': 16 - guest('inventory')['counts'].get('minecraft:melon_slice', 0), 'needed': slices}
+    assert hungry < 20, f'the guest is not hungry: {full}'
+    assert full['fed'] == 20 and full['eaten'] == slices, f'the bar did not fill: {full}'
+    assert using == [None] * 4, f'another bite started with a full food bar: {full}'
+
+    # Chorus fruit can always be eaten, then its group cools down for 20 ticks: the client waits
+    # it out (MultiPlayerGameMode.useItem) and eats the second fruit with the button still held.
+    guest('command', command='clear @s')
+    guest('command', command='give @s minecraft:chorus_fruit 2')
+    guest.wait(5)
+    guest.raw('select', 'minecraft:chorus_fruit')
+    guest.raw('use-item', '--hold', 7.0)
+    guest.wait(10)
+    chorus = {'left': guest('inventory')['counts'].get('minecraft:chorus_fruit', 0),
+              'using': guest('state').get('using')}
+    assert chorus == {'left': 0, 'using': None}, f'the held use did not eat both chorus fruits: {chorus}'
+    return {'full': full, 'chorus': chorus}
+
+
+CHECKS += ['eat_full']
+CHECK_FNS.update(eat_full=check_eat_full)
+
+
 def check_consume_release(host, guest, out):
     """#1293: releasing a consumable in either hand cancels it on client and server, while
     holding it to completion applies its effects and remainder (Consumable.onConsume)."""
@@ -5219,8 +5569,10 @@ def check_consume_release(host, guest, out):
                     assert effects == before, f'{case} applied consumption effects after release: {cancelled}'
                     game.shot(out, f'consume-release-{hand}-{item}')
                     # A sustained press must still consume normally, including the milk's empty bucket.
+                    # The use ends with the server's USE_ITEM_COMPLETE, 32 server ticks after its
+                    # UseItem: room for a busy server before letting go.
                     game.raw('mouse', 'right', 'down')
-                    game.wait(40)
+                    game.wait(50)
                     game.raw('mouse', 'right', 'up')
                     game.wait(10)
                     inventory = game('inventory')
@@ -6234,6 +6586,65 @@ CHECKS += ['recipe_removal']
 CHECK_FNS.update(recipe_removal=check_recipe_removal)
 
 
+def check_recipe_settings(host, guest, out):
+    """RecipeBookComponent sends both settings to the server; each player's
+    own book keeps them when the authoritative world saves and reopens (#2290)."""
+    def inventory(game):
+        back_to_game(game)
+        game.raw('key', 'e', 'tap')
+        game.wait(5)
+        return game('screen')['recipe_book']
+
+    def flags(book):
+        return {'open': book['open'], 'filtering': book['filtering']}
+
+    def set_flags(game, opened, filtering):
+        book = inventory(game)
+        if not book['open']:
+            game.raw('click-at', *centre(book['targets'][0]))
+            game.wait(5)
+            book = game('screen')['recipe_book']
+        if book['filtering'] != filtering:
+            target = next(t for t in book['targets'] if t[2:] == [26.0, 16.0])
+            game.raw('click-at', *centre(target))
+            game.wait(5)
+        if not opened:
+            book = game('screen')['recipe_book']
+            game.raw('click-at', *centre(book['targets'][0]))
+            game.wait(5)
+        actual = flags(game('screen')['recipe_book'])
+        assert actual == {'open': opened, 'filtering': filtering}, f'{game.name}: {actual}'
+        game.shot(out, 'recipe-settings-before')
+        back_to_game(game)
+        return actual
+
+    # Deliberately different settings ensure neither player's book overwrites the other's.
+    before = {host.name: set_flags(host, True, True),
+              guest.name: set_flags(guest, False, True)}
+    host.wait(20)
+    guest.raw('disconnect')
+    host.raw('pause')
+    host.raw('click-button', 'Save and Quit to Title')
+    host.raw('wait-for', 'screen', 'title', '--timeout', 120)
+    host.raw('open', 'Lan')
+    host('wait_ready', seconds=400)
+    port = host.raw('lan', 'open', 0, 'commands')['port']
+    guest.raw('connect', f'127.0.0.1:{port}', GUEST_NAME)
+    guest.raw('wait-for', 'loaded', '--timeout', 300)
+    guest.wait(20)
+    after = {}
+    for game in (host, guest):
+        after[game.name] = flags(inventory(game))
+        game.shot(out, 'recipe-settings-reopened')
+        back_to_game(game)
+    assert after == before, f'saved recipe settings reset: before={before}, after={after}'
+    return {'before': before, 'reopened': after}
+
+
+CHECKS += ['recipe_settings']
+CHECK_FNS.update(recipe_settings=check_recipe_settings)
+
+
 def check_recipe_targets(host, guest, out):
     """RecipeCommand gives and takes the recipes of each target's own ServerRecipeBook: a
     `/recipe give|take <other player>` changes that player's book and reaches their client,
@@ -7110,6 +7521,90 @@ CHECKS += ['guardian-beams']
 CHECK_FNS['guardian-beams'] = check_guardian_beams
 
 
+def check_fangs(host, guest, out):
+    """EvokerFangs: authoritative spawn, event 4, client animation and server removal (#1482)."""
+    x, y, z = (int(v // 1) for v in pos_of(host))
+    tag = 'lan_evoker_fangs'
+    selector = f'@e[type=minecraft:evoker,tag={tag},limit=1]'
+    paths = {g.name: {} for g in (host, guest)}
+    warmup = dict.fromkeys(paths, False)
+    drawn = dict.fromkeys(paths, False)
+    stopped = False
+    photographed = False
+
+    def fangs(status):
+        return [p for p in status['projectiles'] if p['kind'] == 'minecraft:evoker_fangs']
+
+    try:
+        host('command', command='difficulty normal')
+        host('command', command='gamemode creative')
+        guest('command', command='gamemode survival')
+        guest('command', command='effect give @s minecraft:resistance 120 4 true')
+        host('command', command=f'fill {x - 10} {y - 1} {z - 10} {x + 10} {y - 1} {z + 18} minecraft:stone')
+        host('command', command=f'fill {x - 10} {y} {z - 10} {x + 10} {y + 8} {z + 18} minecraft:air')
+        host('command', command=f'tp @s {x + 4.5} {y} {z - 2.5}')
+        guest('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}')
+        guest.wait(10)
+        host('command', command=f'summon minecraft:evoker {x + 0.5} {y} {z + 9.5} '
+                                f'{{PersistenceRequired:1b,Tags:["{tag}"]}}')
+        for game in (host, guest):
+            game.raw('look-at', x + 0.5, y + 0.5, z + 5.5)
+        for _ in range(200):
+            guest.wait(2)
+            statuses = {g.name: g('status') for g in (host, guest)}
+            for name, status in statuses.items():
+                live = fangs(status)
+                ids = [f['id'] for f in live]
+                assert all(ids) and len(ids) == len(set(ids)), f'{name}: invalid fang ids {ids}'
+                warmup[name] |= any(not f['started'] for f in live)
+                drawn[name] |= status['fangs_vertices'] > 0
+                for f in live:
+                    paths[name].setdefault(f['id'], []).append(f)
+            if paths['host'] and not stopped:
+                host('command', command=f'data merge entity {selector} {{NoAI:1b}}')
+                stopped = True
+            if (all(drawn.values()) and not photographed
+                    and any(f['started'] and 8 <= f['life'] <= 16
+                            for f in fangs(statuses['guest']))):
+                host('command', command='tick freeze')
+                try:
+                    for game in (host, guest):
+                        game.raw('key', 'f1', 'tap')
+                        try:
+                            game.shot(out, 'evoker-fangs')
+                        finally:
+                            game.raw('key', 'f1', 'tap')
+                finally:
+                    host('command', command='tick unfreeze')
+                photographed = True
+            if stopped and not any(fangs(s) for s in statuses.values()):
+                break
+        lab.write_json(out / 'evoker-fangs.json', {'paths': paths, 'warmup': warmup, 'drawn': drawn})
+        assert all(warmup.values()), f'fang warmup not received: {warmup}'
+        assert all(drawn.values()), f'fang renderer produced no geometry: {drawn}'
+        assert paths['host'].keys() == paths['guest'].keys(), 'clients received different fang ids'
+        for id, samples in paths['host'].items():
+            other = paths['guest'][id]
+            assert all(f['position'] == samples[0]['position'] for f in samples + other), \
+                f'fang {id} is not at its authoritative position'
+            for name, frames in (('host', samples), ('guest', other)):
+                life = {f['life'] for f in frames if f['started']}
+                assert len(life) > 1, f'{name}: fang {id} did not animate: {frames}'
+        assert not any(fangs(g('status')) for g in (host, guest)), 'fangs survived server removal'
+    finally:
+        host('command', command='tick unfreeze')
+        host('command', command=f'kill @e[tag={tag}]')
+        # The evoker can summon vexes before fangs; killing it leaves those summons alive.
+        host('command', command=f'kill @e[type=minecraft:vex,x={x},y={y},z={z},distance=..32]')
+        guest('command', command='effect clear @s')
+        face_each_other(host, guest)
+    return {'fangs': len(paths['host']), 'warmup': warmup, 'drawn': drawn, 'removed': True}
+
+
+CHECKS += ['fangs']
+CHECK_FNS.update(fangs=check_fangs)
+
+
 def check_sonic(host, guest, out):
     """A real warden's ray reaches connected clients once, with normal damage.
 
@@ -7235,9 +7730,15 @@ def check_cushions(host, guest, out):
         assert player('status').get('riding') is None, seen
         player('command', command='gamemode creative')
         player.raw('look-at', at[0], at[1] + .125, at[2])
+        before = {g.name: g('status').get('particles', {}).get('block', 0) for g in (host, guest)}
         player.raw('mouse', 'left', 'click')
         player.wait(10)
         assert not cushions(host) and not cushions(player), seen
+        seen[label]['break_particles'] = {
+            g.name: g('status').get('particles', {}).get('block', 0) - before[g.name]
+            for g in (host, guest)
+        }
+        assert all(n == 10 for n in seen[label]['break_particles'].values()), seen
     return seen
 
 
@@ -7298,5 +7799,56 @@ CHECKS += ['forced-levels']
 CHECK_FNS['forced-levels'] = check_forced_levels
 
 
+def check_dig_stop(host, guest, out):
+    """#1340 and #1908: a block the client breaks at once leaves the server no dig to keep.
+
+    MultiPlayerGameMode sends no STOP or ABORT for a creative break or an instant
+    survival break (its isDestroying stays false), so the server must forget the dig on
+    its own, as ServerPlayerGameMode.handleBlockBreakAction's creative and insta-mine
+    branches do. Otherwise the server keeps mining the old spot: the block put back
+    there is destroyed again (#1340) and the mining sound keeps playing at it (#1908).
+    """
+    result = {}
+    spots = apart(host, guest)
+    for label, player in (('host', host), ('guest', guest)):
+        x, y, z = spots[label]
+        cell = (x, y + 1, z + 2)
+        seen = result[label] = {}
+        for mode, block in (('creative', 'minecraft:stone'), ('survival', 'minecraft:dead_bush')):
+            player('command', command=f'gamemode {mode}')
+            player('command', command='clear @s')
+            host('command', command=f'fill {x - 1} {y} {z + 1} {x + 1} {y + 3} {z + 4} minecraft:air')
+            host('command', command=f'setblock {cell[0]} {cell[1]} {cell[2]} {block}')
+            player.wait(10)
+            before = {g.name: heard(g, 'minecraft:block.stone.hit') for g in (host, guest)}
+            player.raw('look-at', f'{cell[0] + 0.5:.2f}', f'{cell[1] + 0.4:.2f}', f'{cell[2] + 0.5:.2f}')
+            # One left-click, then the attack released.
+            player.raw('mouse', 'left', 'click')
+            player.wait(40)
+            seen[f'{mode} broken'] = host.raw('block', *cell).get('block')
+            seen[f'{mode} mining'] = player('state').get('mining')
+            # The block put back must stay: the server has no dig left to destroy it.
+            host('command', command=f'setblock {cell[0]} {cell[1]} {cell[2]} minecraft:stone')
+            player.wait(100)
+            seen[f'{mode} replacement'] = [g.raw('block', *cell).get('block') for g in (host, player)]
+            seen[f'{mode} hits'] = {g.name: heard(g, 'minecraft:block.stone.hit') - before[g.name]
+                                    for g in (host, guest)}
+            host('command', command=f'setblock {cell[0]} {cell[1]} {cell[2]} minecraft:air')
+        assert seen['creative broken'] == 'minecraft:air', f'{label}: the creative break failed: {seen}'
+        assert seen['survival broken'] == 'minecraft:air', f'{label}: the instant break failed: {seen}'
+        assert seen['creative mining'] is None, f'{label}: the client still digs: {seen}'
+        assert seen['survival mining'] is None, f'{label}: the client still digs: {seen}'
+        for mode in ('creative', 'survival'):
+            assert seen[f'{mode} replacement'] == ['minecraft:stone'] * 2, \
+                f'{label} {mode}: the server kept digging: {seen}'
+            assert all(hits == 0 for hits in seen[f'{mode} hits'].values()), \
+                f'{label} {mode}: the mining sound kept playing: {seen}'
+    return result
+
+
+CHECKS += ['dig_stop']
+CHECK_FNS['dig_stop'] = check_dig_stop
+
+
 if __name__ == '__main__':
     main()
diff --git a/tools/parity.py b/tools/parity.py
index dbff8c146..38d113cab 100644
--- a/tools/parity.py
+++ b/tools/parity.py
@@ -26,6 +26,11 @@ change costs only the Rust side. A harness that fails while reusing oracle
 results is rerun fresh, and stops reusing them if it then passes. --all and
 --fresh never reuse them.
 
+A harness listed in parity_hosts.json's "known_flaky" (each with its reason)
+that fails runs once more from scratch instead, and a pass then counts. Every
+retry is printed as a RETRIED line in the summary and in the CI job's summary.
+Fix the cause, then take the harness off the list: nothing else gets this retry.
+
 Harness probes build into .local/parity-target with release optimisations but
 without LTO and with 16 codegen units (`PROFILE` below), which builds in
 seconds instead of minutes. Rust does not let those settings change results:
@@ -43,6 +48,7 @@ import os
 from pathlib import Path, PurePosixPath
 import re
 import shutil
+import signal
 import socket
 import subprocess
 import sys
@@ -794,16 +800,21 @@ class LocalExecutor:
         self.name, self.jobs, self.memory_budget, self.timeout = HOST, jobs, memory_budget, timeout
         self.max_peak = max_peak  # set while other machines can take heavier harnesses
         self.running = {}
+        self.solo = set()  # harnesses that run alone here (solo_harnesses)
         self.dead = False  # this machine never drops out, unlike a remote host
         self.available, self.measured = 0, 0.0
         (STATE_DIR / "logs").mkdir(parents=True, exist_ok=True)
         (STATE_DIR / "traces").mkdir(parents=True, exist_ok=True)
 
     def free(self):
+        if any(harness_of(label) in self.solo for label in self.running):
+            return 0
         return self.jobs - len(self.running)
 
     def accepts(self, name):
-        return True
+        # A solo harness waits until nothing else runs here; the others fill the slots meanwhile, so solo ones
+        # run last, alone.
+        return name not in self.solo or not self.running
 
     def fits(self, expected, only_here=True):
         """Admission by recorded peak, within the budget and leaving MEMORY_RESERVE of what is free now.
@@ -1014,11 +1025,26 @@ def harness_of(label):
     return label.split("~")[0]
 
 
-def run(selected, state, hasher, environment_digest, executors, reuse_oracles, rounds=None):
+def keep_first_log(label):
+    """Move a harness's log aside before its retry writes a new one; returns where it went."""
+    log = STATE_DIR / "logs" / f"{label}.log"
+    kept = log.with_name(f"{label}.first-run.log")
+    try:
+        log.replace(kept)
+    except OSError:
+        return log  # a remote host's run: its log stays on that machine
+    return kept
+
+
+def run(selected, state, hasher, environment_digest, executors, reuse_oracles, rounds=None, known_flaky=None):
     """Run the selected harnesses on the executors. rounds: how many times each must run (default once); its runs
-    must agree, and a harness that both passes and fails is reported as flaky and recorded as failing."""
+    must agree, and a harness that both passes and fails is reported as flaky and recorded as failing.
+    known_flaky ({name: reason}, tools/parity_hosts.json): a harness listed there that fails its single round runs
+    once more, from scratch; its record keeps `retried` (the first run's log is kept beside its own)."""
     records = state["harnesses"]
     rounds = rounds or {}
+    known_flaky = known_flaky or {}
+    second_chance = set()  # known flaky harnesses that already failed once in this run
     # Longest first, so the slow harnesses don't start last; a harness's later rounds after its first.
     queue = sorted((name if index == 1 else f"{name}~{index}" for name in selected for index in range(1, rounds.get(name, 1) + 1)),
                    key=lambda label: (-records.get(harness_of(label), {}).get("seconds", 1e9), label))
@@ -1041,7 +1067,9 @@ def run(selected, state, hasher, environment_digest, executors, reuse_oracles, r
                 if pick is None:
                     break
                 name = harness_of(pick)
-                reuse = reuse_oracles and records.get(name, {}).get("oracle_reuse", True) and pick not in retried
+                # A retry runs the oracle again too: it may be the side that failed (mob_ai's heap).
+                reuse = reuse_oracles and records.get(name, {}).get("oracle_reuse", True) and pick not in retried \
+                    and name not in second_chance
                 if not executor.start(pick, selected[name], reuse, records.get(name, {}).get("peak_bytes", DEFAULT_MEMORY),
                                       SHARDS.get(name)):
                     break
@@ -1066,9 +1094,12 @@ def run(selected, state, hasher, environment_digest, executors, reuse_oracles, r
                 queue.insert(0, label)
                 continue
             passed = record["status"] == "pass"
-            if not passed and reused and label == name and records.get(name, {}).get("status") != "fail":
+            flaky_retry = rounds.get(name, 1) == 1 and base_name(name) in known_flaky
+            if not passed and reused and label == name and records.get(name, {}).get("status") != "fail" \
+                    and not flaky_retry:
                 # A new failure might come from a reused oracle result: run it again from scratch. Later rounds reuse
-                # what the first just validated, so their failures count (a flaky harness).
+                # what the first just validated, so their failures count (a flaky harness). A known flaky harness
+                # gets its own retry below instead, which keeps reusing oracle results afterwards.
                 retried.add(label)
                 queue.insert(0, label)
                 print(f"retry {label} without reused oracle results", flush=True)
@@ -1086,8 +1117,19 @@ def run(selected, state, hasher, environment_digest, executors, reuse_oracles, r
             if len(done[name]) < rounds.get(name, 1):
                 continue
             runs = done.pop(name)
+            if runs[0]["status"] != "pass" and flaky_retry and name not in second_chance:
+                second_chance.add(name)
+                first_log = keep_first_log(label)
+                print(f"RETRIED {name}: failed, and it is a known flaky harness ({known_flaky[base_name(name)]}): "
+                      f"running it once more (first run's log: {first_log})", flush=True)
+                queue.insert(0, label)
+                continue
             record = dict(runs[0], status="pass" if all(run["status"] == "pass" for run in runs) else "fail",
                           rounds=len(runs))
+            if name in second_chance:
+                record["retried"] = "known flaky"
+            elif label in retried:
+                record["retried"] = "reused oracle results"
             if len({run["status"] for run in runs}) > 1:
                 record["flaky"] = [run["status"] for run in runs]
                 print(f"FLAKY {name}: {', '.join(record['flaky'])} in {len(runs)} runs", flush=True)
@@ -1098,6 +1140,14 @@ def run(selected, state, hasher, environment_digest, executors, reuse_oracles, r
     return results, time.monotonic() - started_all
 
 
+def exit_on_termination():
+    """SIGTERM and SIGHUP (a cancelled CI job, a dropped ssh) end this process through its finally blocks, which stop
+    the running harnesses. Each runs in its own session, so without that they, and the vanilla servers they started,
+    outlive it (orphans of days were found on the Mac mini's runners, 2026-10-26)."""
+    for number in (signal.SIGTERM, signal.SIGHUP):
+        signal.signal(number, lambda received, _frame: sys.exit(128 + received))
+
+
 def worker_main(shared_local):
     """`parity.py --worker SHARED_LOCAL`: run harnesses sent as JSON lines on stdin, answer on stdout."""
     import queue as queues
@@ -1133,13 +1183,20 @@ def worker_main(shared_local):
     built, errors = prebuild(first["prebuild"], default_build_jobs()) if first["prebuild"] else (True, "")
     executor = LocalExecutor(MACHINE_JOBS, int(memory_available() * 0.75), first["timeout"])
     send({"hello": {"jobs": MACHINE_JOBS, "memory": executor.memory_budget, "built": built, "errors": errors[-4000:]}})
+    try:
+        return serve(executor, inbox, queues.Empty, send, state, hasher)
+    finally:
+        executor.stop()
+
+
+def serve(executor, inbox, empty, send, state, hasher):
+    """The worker's loop: start what the coordinating runner sends, report what finished, until its stdin ends."""
     while True:
         try:
             message = inbox.get(timeout=0.2)
-        except queues.Empty:
+        except empty:
             message = False
         if message is None:
-            executor.stop()
             save_state(state)
             return 0
         if message:
@@ -1210,6 +1267,101 @@ def trace_main(output, script, arguments):
 
 # Files every harness's result depends on (part of environment_key): a change to one affects them all.
 SHARED_INPUTS = {"research-lock.json", "Cargo.lock"}
+# Manifest sections that say what a crate is and where its targets are, not what it builds with.
+MANIFEST_SECTION_KEPT = re.compile(r"\[\[?(?:package|lib|bin|example|test|bench|lints|badges)\b[^\]]*\]\]?$")
+WORKSPACE_CRATE = r"(horizon[\w-]*|cargo-horizon-mod|xtask)"
+# A workspace crate named as a dependency (by path, or from the workspace's own table) without choosing its features,
+# or listed as a member.
+WORKSPACE_LINE = re.compile(WORKSPACE_CRATE + r'\s*=\s*(?:\{(?![^}]*\bfeatures\b)[^}]*\b(?:path|workspace)\s*=[^}]*\}|true)'
+                            r'|' + WORKSPACE_CRATE + r'\.workspace\s*=\s*true|"crates/[^"]+",?')
+# A workspace crate named as a dependency with some of its features turned on.
+WORKSPACE_FEATURES = re.compile(WORKSPACE_CRATE + r'\s*=\s*\{(?=[^}]*\b(?:path|workspace)\s*=)(?![^}]*default-features)'
+                                r'[^}]*\bfeatures\s*=\s*\[([^\]]*)\][^}]*\}')
+
+
+def git_show(base, path):
+    """path's content at commit base, or None where it didn't exist."""
+    result = subprocess.run(["git", "show", f"{base}:{path}"], cwd=ROOT, capture_output=True, text=True)
+    return result.stdout if result.returncode == 0 else None
+
+
+def manifest_lines(text):
+    """A Cargo.toml's lines that decide what is built: (section, line) pairs, without its package's identity and
+    targets, comments, or workspace crates (whose code counts through its own sources)."""
+    lines, section = set(), ""
+    name = re.search(r'^\[package\][^\[]*?^name\s*=\s*"([^"]+)"', text or "", re.M | re.S)
+    for raw in (text or "").splitlines():
+        line = re.sub(r"\s+", " ", raw.split("#", 1)[0]).strip()
+        if not line:
+            continue
+        if line.startswith("["):
+            # A crate's features are its own: the same line in two crates means two things.
+            section = f"[features] of {name.group(1) if name else '?'}" if line == "[features]" else line
+            continue
+        if MANIFEST_SECTION_KEPT.match(section) or WORKSPACE_LINE.fullmatch(line) or \
+                section == "[workspace]" and (line.startswith("members =") or line.startswith('"') or line == "]"):
+            continue
+        lines.add((section, line))
+    return lines
+
+
+def lock_packages(text):
+    """Cargo.lock's packages from a registry or git (with their versions and checksums); workspace crates' entries
+    only list what their manifests say."""
+    return {block.strip() for block in (text or "").split("[[package]]") if "\nsource = " in block}
+
+
+def workspace_only_manifests(changed, base):
+    """The changed Cargo.lock and Cargo.toml files whose changes only add, remove or move workspace crates (a crate
+    split): no external package, version, feature, or build setting changed across them. Their crates' code counts
+    through its own sources, so these files don't make every harness linking the crates rerun."""
+    manifests = sorted(path for path in changed if path == "Cargo.lock" or path.endswith("Cargo.toml"))
+    if not manifests or base is None:
+        return set()
+    if "Cargo.lock" in manifests and \
+            lock_packages(git_show(base, "Cargo.lock")) != lock_packages((ROOT / "Cargo.lock").read_text(encoding="utf-8")):
+        return set()
+    tomls = [path for path in manifests if path != "Cargo.lock"]
+    before = set().union(*(manifest_lines(git_show(base, path)) for path in tomls)) if tomls else set()
+    after = set().union(*(manifest_lines((ROOT / path).read_text(encoding="utf-8") if (ROOT / path).exists() else None)
+                          for path in tomls)) if tomls else set()
+    # Workspace crates' features that a changed line defines or turns on: they change what compiles of that crate's
+    # sources, which is fine only where every source naming them changed too (a split: the crate's files are new).
+    gated = set()
+    for section, line in before ^ after:
+        wanted = WORKSPACE_FEATURES.fullmatch(line)
+        if wanted:
+            gated |= {(wanted.group(1), feature) for feature in re.findall(r'"([^"]+)"', wanted.group(2))}
+        elif section.startswith("[features] of ") and re.fullmatch(r'[\w-]+ = \[(?: ?"[\w-]+",?)*\s*\]', line):
+            gated.add((section[len("[features] of "):], line.split(" ", 1)[0]))
+        else:
+            return set()  # an external package, a feature reaching one ("dep:", "crate/feature"), a build setting
+    return set(manifests) if all(feature_sources_changed(crate, feature, changed) for crate, feature in gated) else set()
+
+
+def feature_sources_changed(crate, feature, changed):
+    """Whether every Rust source of workspace crate `crate` that names `feature`, or a feature it turns on, is in
+    changed (False where the crate isn't found)."""
+    listed = subprocess.run(["git", "ls-files", "*Cargo.toml"], cwd=ROOT, capture_output=True, text=True)
+    manifests = [ROOT / path for path in listed.stdout.split()] if listed.returncode == 0 else list(ROOT.rglob("Cargo.toml"))
+    for manifest in manifests:
+        text = manifest.read_text(encoding="utf-8") if manifest.exists() else ""
+        if re.search(r'^\[package\][^\[]*?^name\s*=\s*"' + re.escape(crate) + '"', text, re.M | re.S):
+            break
+    else:
+        return False
+    table = re.search(r"^\[features\]\n(.*?)(?=^\[|\Z)", text, re.M | re.S)
+    implies = {name: re.findall(r'"([^"]+)"', value) for name, value in
+               re.findall(r'^([\w-]+)\s*=\s*\[([^\]]*)\]', table.group(1) if table else "", re.M)}
+    names, todo = set(), [feature]
+    while todo:
+        name = todo.pop()
+        if name not in names:
+            names.add(name)
+            todo += [implied for implied in implies.get(name, []) if "/" not in implied and ":" not in implied]
+    named = re.compile(r'feature\s*=\s*"(?:' + "|".join(map(re.escape, sorted(names))) + r')"')
+    return all(path.relative_to(ROOT).as_posix() in changed for path in manifest.parent.rglob("*.rs")
+               if named.search(path.read_text(encoding="utf-8", errors="replace")))
 
 
 def changed_files(ref):
@@ -1274,7 +1426,7 @@ def affected_harnesses(found, records, changed, reach=True, base=None):
             affected.add(name)
             continue
         plain = {path.split(KEEP)[0] for path in dependencies}
-        hit = plain & changed
+        hit = (plain & changed) | parity_reach.unrecorded(ROOT, plain, changed)
         if not hit:
             continue
         if graph is None or any(not path.startswith("crates/") for path in hit):
@@ -1309,12 +1461,51 @@ def platform_skips(config):
     return dict(config.get("linux_only", {}))
 
 
+def known_flaky(config):
+    """Harnesses tools/parity_hosts.json lists as failing now and then for a cause not fixed yet: one that fails runs
+    once more, and passing then counts, reported as RETRIED. {name: reason}"""
+    return dict(config.get("known_flaky", {}))
+
+
+def solo_harnesses(config):
+    """Harnesses tools/parity_hosts.json's "solo" lists ({name: reason}: those driving game windows, whose frames
+    are drawn on the CPU on Linux runners) run alone on a machine with SOLO_CPUS CPUs or fewer for this process
+    (playhorizon's runner has 4): beside other harnesses there they lose ticks between control requests. The set,
+    or an empty one on a bigger machine. PARITY_SOLO=1 or 0 forces it on or off."""
+    forced = os.environ.get("PARITY_SOLO")
+    cpus = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count() or 1
+    if forced == "0" or forced != "1" and cpus > SOLO_CPUS:
+        return set()
+    return set(config.get("solo", {}))
+
+
+SOLO_CPUS = 4
+
+
 def named_only(config):
     """Harnesses tools/parity_hosts.json keeps out of every automatic selection (--changed, --failed, the default,
     --flake-check): they run only when named or with --all, the nightly audit. {name: reason}"""
     return dict(config.get("named_only", {}))
 
 
+def report_retries(results, flaky):
+    """Say loudly which harnesses needed their one retry (a known flaky one, or one that failed with reused oracle
+    results), here and in the CI job's summary: a pass on the retry counts, so this is where flakes stay visible."""
+    def why(name, record):
+        if record["retried"] == "known flaky":
+            return (f"known flaky: {flaky.get(base_name(name), '?')}; first run's log: "
+                    f"{STATE_DIR / 'logs' / (name + '.first-run.log')}")
+        return "its first run reused oracle results; it no longer reuses them" if record["status"] == "pass" else \
+            "its first run reused oracle results"
+    lines = [f"RETRIED {name}: failed, then {'passed' if record['status'] == 'pass' else 'failed again'} on its one "
+             f"retry ({why(name, record)})" for name, record in sorted(results.items()) if record.get("retried")]
+    for line in lines:
+        print(line, flush=True)
+    if lines and os.environ.get("GITHUB_STEP_SUMMARY"):
+        with open(os.environ["GITHUB_STEP_SUMMARY"], "a", encoding="utf-8") as summary:
+            summary.write("### Harnesses that failed once, then ran again\n" + "".join(f"- {line}\n" for line in lines))
+
+
 def finished_run(failed):
     """Record that this run completed, for tools/gate.py: a crashed runner never writes it."""
     STATE_DIR.mkdir(parents=True, exist_ok=True)
@@ -1324,6 +1515,7 @@ def finished_run(failed):
 def main():
     if len(sys.argv) > 1 and sys.argv[1] == "--trace":
         return trace_main(sys.argv[2], sys.argv[3], sys.argv[4:])
+    exit_on_termination()
     if len(sys.argv) > 1 and sys.argv[1] == "--worker":
         return worker_main(sys.argv[2])
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
@@ -1389,7 +1581,11 @@ def main():
         if args.changed:
             merge_base = subprocess.run(["git", "merge-base", "HEAD", args.changed], cwd=ROOT, capture_output=True, text=True)
             base = merge_base.stdout.strip() or None
-        affected = affected_harnesses(found, records, changed, reach=not args.by_crate, base=base)
+        moved = workspace_only_manifests(changed, base) if not args.by_crate else set()
+        if moved:
+            print(f"{', '.join(sorted(moved))}: only workspace crates added, removed or moved; their sources count "
+                  "instead", flush=True)
+        affected = affected_harnesses(found, records, changed - moved, reach=not args.by_crate, base=base)
         chosen = [name for name in found if name in affected and stale(name, state, hasher, environment)]
         print(f"{len(changed)} files changed{since}: {len(affected)} harnesses "
               f"depend on them, {len(chosen)} without a pass for their current inputs.", flush=True)
@@ -1449,6 +1645,7 @@ def main():
         jobs = 1  # harnesses that can only run here still need a slot
     remotes = [RemoteExecutor(host, config["hosts"][host], artifacts, config.get("local_only", {}), args.timeout)
                for host in hosts]
+    local = None
     try:
         if jobs:
             print("Building probes...", flush=True)
@@ -1461,16 +1658,22 @@ def main():
         where = "".join(f", plus {host}" for host in hosts)
         print(f"Running {len(selected)} harnesses, {jobs} at a time here{where}...", flush=True)
         reuse_oracles = not (args.fresh or args.all)
-        executors = [*remotes, LocalExecutor(jobs, int(memory_available() * 0.75), args.timeout,
-                                             REMOTE_LOCAL_PEAK if remotes and args.jobs is None else None)]
-        results, elapsed = run(selected, state, hasher, environment_key(hasher), executors, reuse_oracles, rounds)
+        local = LocalExecutor(jobs, int(memory_available() * 0.75), args.timeout,
+                              REMOTE_LOCAL_PEAK if remotes and args.jobs is None else None)
+        local.solo = solo_harnesses(config)
+        if local.solo & {harness_of(name) for name in selected}:
+            print(f"Alone on this machine ({SOLO_CPUS} CPUs or fewer), after the others: "
+                  f"{', '.join(sorted(local.solo & {harness_of(name) for name in selected}))}", flush=True)
+        results, elapsed = run(selected, state, hasher, environment_key(hasher), [*remotes, local], reuse_oracles,
+                               rounds, known_flaky(config))
     finally:
-        for executor in remotes:
+        for executor in [*remotes, *([local] if local else [])]:
             executor.stop()
     save_state(state)
     failed = sorted(name for name, record in results.items() if record["status"] != "pass")
     finished_run(failed)
     print(f"\n{len(results) - len(failed)} passed, {len(failed)} failed in {elapsed / 60:.1f} min.")
+    report_retries(results, known_flaky(config))
     for index, name in enumerate(failed):
         log = STATE_DIR / 'logs' / (name + '.log')
         print(f"  {name}: {log}")
diff --git a/tools/parity_hosts.json b/tools/parity_hosts.json
index b56106e4d..cec022194 100644
--- a/tools/parity_hosts.json
+++ b/tools/parity_hosts.json
@@ -23,24 +23,33 @@
   "playhorizon": {
    "ssh": "ludovic@playhorizon",
    "root": ".actions-runners/horizon/parity-host",
-   "shell": "systemd-run --user --scope --quiet --slice=horizon-ci.slice --unit=horizon-parity-worker-$$ bash -c",
+   "shell": "systemd-run --user --scope --quiet --slice=horizon-ci.slice --unit=horizon-parity-worker-$$ taskset -c 0-3 bash -c",
    "setup": "test ! -e ~/.actions-runners/horizon/paused && set -a && . ~/.actions-runners/horizon/.env && set +a && export PATH=$(cat ~/.actions-runners/horizon/.path) && unset WAYLAND_DISPLAY && export DISPLAY=:$(cat ~/.actions-runners/horizon/display)",
    "python": "python3.13",
-   "jobs": 6,
+   "jobs": 3,
    "nice": 10,
    "exclude": {
     "mob_ai": "the vanilla oracle runs out of its 3 GB heap here (OutOfMemoryError in IO workers; passes on the desktop and the Mac) - 2026-10-26 trial",
     "lan_integration": "two clients rendered on the CPU (lavapipe): different timing subtests fail on each run (elytra, consume-release, barter, critical-hits) - 2026-10-26 trial",
     "world_reopen": "failed twice here (no Save and Quit button after reopening; the minecart-count flake), passes on the desktop - 2026-10-26 trial"
    },
-   "note": "a partner's server (Ubuntu, 8 EPYC threads, 30 GB, Detroit; tailnet only), used by nothing else: 6 jobs, in the CI runner's environment, slice and Xvfb screen (tools/ci/linux-runner.sh); the always-on Linux host since the ThinkPad stopped running harnesses (2026-10-26)"
+   "note": "a partner's server (Ubuntu, 8 EPYC threads, 30 GB, Detroit; tailnet only), its CI runner has CPUs 4-7, so workers get 0-3 (as tools/remote.sh runs do) and 3 jobs, in the CI runner's environment, slice and Xvfb screen (tools/ci/linux-runner.sh); the always-on Linux host since the ThinkPad stopped running harnesses (2026-10-26)"
   }
  },
  "local_only": {
   "save_roundtrip": "runs the game on a virtual screen (vscreen) with a null ALSA device, or offscreen in the logged-in macOS session"
  },
  "linux_only": {},
+ "solo": {
+  "remote_fireball": "two game windows (lan_e2e); on 4 CPUs beside other harnesses, screenshots and control requests take ticks the check needs",
+  "remote_fireworks": "two game windows (lan_e2e); a screenshot took ~1.5 s beside 3 other harnesses on playhorizon's runner, past the sparks' life (2026-10-27)",
+  "server_player_sculk": "two game windows (lan_e2e); failed on playhorizon's runner beside other harnesses, passes alone (2026-10-27)",
+  "world_reopen": "a game window reopening a world: failed on playhorizon's runner beside other harnesses (2026-10-27)"
+ },
  "named_only": {
   "lan_integration": "the whole lan_e2e suite: ~40 min a run on a loaded runner, and single checks flake under load; run it by name, or tools/lan_e2e.py"
+ },
+ "known_flaky": {
+  "world_reopen": "counted 4 minecarts instead of 3 once on a loaded Mac mini runner, then passed at the same head (10-26)"
  }
 }
diff --git a/tools/parity_reach.py b/tools/parity_reach.py
index dc61f6215..b5be2a192 100644
--- a/tools/parity_reach.py
+++ b/tools/parity_reach.py
@@ -7,8 +7,8 @@ of the workspace's current sources whose nodes are items:
 
 - everything in an entry is reached, and so is everything in a Rust file the module tree doesn't place (an
   `include!`d source);
-- a module is open when it is a crate root, holds reached code, or is named in a path (`name::`, `use ...name`) by
-  reached code while its parent is open;
+- a module is open when it holds reached code, or is named in a path (`name::`, `use ...name`) by reached code while
+  its parent is open; a library's root once reached code names its crate (`horizon_world`);
 - a free item (fn, struct, enum, union, trait, type, const, static, an item-level macro call's items) is reached when
   reached code in its own module or below it mentions its name, or when its module is open and reached code names
   it in a path or an import, or when its module is glob-imported (`use m::*`) and its name is mentioned;
@@ -608,8 +608,8 @@ class SourceGraph:
 
         try:
             for path in universe:
-                if path.endswith("/src/lib.rs") or path in entries or path not in self.parent:
-                    open_module(path, "crate root or entry")
+                if path in entries or path not in self.parent and not path.endswith("/src/lib.rs"):
+                    open_module(path, "entry, or a file no module places")
             for node in seeds:
                 reach(node, "entry" if node[0] in entries else "always counted")
             for path in entries & universe:
@@ -624,6 +624,12 @@ class SourceGraph:
                 label = (item.get("names") or [item["kind"]])[0] if member is None else item["members"][member]["name"]
                 source = sets_of(node, item)
                 why = f"{path} ({label})"
+                # A library's root opens once reached code names the crate (`horizon_world::`, `use horizon_command
+                # as command`): its items are out of reach until then.
+                for word in (source["mentions"] | source["paths"]) & idents.keys():
+                    root = f"crates/{idents[word]}/src/lib.rs"
+                    if root in universe and root not in opened:
+                        open_module(root, f"{why} names {word}")
                 # Plain mentions reach items of this file and of the modules above it.
                 ancestor, new = path, source["mentions"]
                 while ancestor is not None and new:
@@ -709,6 +715,35 @@ def is_workspace_rust(path):
     return path.startswith("crates/") and path.endswith(".rs") and path.count("/") >= 2
 
 
+PATH_DEPENDENCY = re.compile(r'path\s*=\s*"\.\./([\w-]+)"')
+
+
+@functools.cache
+def _path_dependencies(root, crate):
+    manifest = Path(root) / "crates" / crate / "Cargo.toml"
+    text = manifest.read_text(encoding="utf-8") if manifest.is_file() else ""
+    return frozenset(PATH_DEPENDENCY.findall(text))
+
+
+def linked_crates(root, crates):
+    """The workspace crates (folders under crates/) that crates link, themselves included: their path dependencies,
+    transitively. A harness recorded before code moved to a new crate links that crate without naming its files."""
+    found, queue = set(crates), list(crates)
+    while queue:
+        for dependency in _path_dependencies(str(root), queue.pop()):
+            if dependency not in found:
+                found.add(dependency)
+                queue.append(dependency)
+    return found
+
+
+def unrecorded(root, plain, changed):
+    """Changed workspace Rust files of crates a harness's recorded crates link but its record doesn't name."""
+    crates = {crate_of(path) for path in plain if path.startswith("crates/") and path.count("/") >= 2}
+    linked = linked_crates(root, crates) - crates
+    return {path for path in changed if is_workspace_rust(path) and crate_of(path) in linked}
+
+
 DECLARATION_LINE = re.compile(rf"\s*(?:pub(?:\([^)]*\))?\s+)?mod\s+({IDENT})\s*;")
 
 
@@ -758,7 +793,7 @@ def narrow(dependencies, artifacts, graph, changed=(), stop=frozenset()):
     plain = [dependency.split("#keep:")[0] for dependency in dependencies]
     crates = {crate_of(path) for path in plain if path.startswith("crates/") and path.count("/") >= 2}
     rust = {path for path in plain if is_workspace_rust(path)}
-    added = {path for path in changed if is_workspace_rust(path) and crate_of(path) in crates
+    added = {path for path in changed if is_workspace_rust(path) and crate_of(path) in linked_crates(graph.root, crates)
              and path not in rust and (graph.root / path).is_file()}
     entries = graph.entries(artifacts, rust)
     if entries is None:
diff --git a/tools/port_regen.py b/tools/port_regen.py
index 8ce639f21..4d69b0986 100644
--- a/tools/port_regen.py
+++ b/tools/port_regen.py
@@ -251,7 +251,7 @@ GENERATORS = [
     ("lan_command_order", ["crates/horizon-client/src/lan/command_order.rs"],
      lambda root, version, store, build: [python(), "tools/generate_lan_command_order.py"]),
     ("command_suggestions", ["crates/horizon-client/src/lan/command_suggestions.rs"], gen_suggestions),
-    ("vanilla_command_order", ["crates/horizon-client/src/command/vanilla_order.rs"], gen_vanilla_order),
+    ("vanilla_command_order", ["crates/horizon-command/src/vanilla_order.rs"], gen_vanilla_order),
 ]
 
 
diff --git a/tools/port_report.py b/tools/port_report.py
index 9006576dd..f8e81b6ee 100644
--- a/tools/port_report.py
+++ b/tools/port_report.py
@@ -40,7 +40,7 @@ GENERATORS = [
      lambda d: bool(d["commands"]["added"] or d["commands"]["removed"] or d["commands"]["changed"])),
     ("crates/horizon-client/src/lan/command_order.rs", "python3 tools/generate_lan_command_order.py",
      lambda d: bool(d["commands"]["added"] or d["commands"]["removed"])),
-    ("crates/horizon-client/src/command/vanilla_order.rs", "python3 tools/generate_command_order.py",
+    ("crates/horizon-command/src/vanilla_order.rs", "python3 tools/generate_command_order.py",
      lambda d: bool(d["commands"]["added"] or d["commands"]["removed"])),
     ("crates/horizon-world/src/datafix/block_state_data.txt", "python3 tools/gen_block_state_data.py",
      lambda d: "net/minecraft/util/datafix/fixes/BlockStateData" in d["classes"]["changed"]),
diff --git a/tools/pr_ready.py b/tools/pr_ready.py
index 5b1622e2e..b741e475e 100755
--- a/tools/pr_ready.py
+++ b/tools/pr_ready.py
@@ -7,12 +7,13 @@
     python3 tools/pr_ready.py --quick               # without running the vanilla harnesses
 
 From the files the branch changes since its merge base with --base (committed or not) it decides what to run:
-rustfmt, clippy with warnings denied and the tests of the touched crates; the launcher (its own workspace) the
-same way when it, horizon-prepare or horizon-theme changed; crates/horizon-theme/tokens.css against horizon-theme;
-Cargo.lock changing only with a Cargo.toml; the Python tests and the public-tree check; and the vanilla
-harnesses the changes can affect, picked as CI's parity job picks them (tools/parity.py --changed). Harnesses run
-where the vanilla data is (a prepared .local/ here, or the Mac mini); elsewhere they are listed for CI.
-Clippy checks all targets of touched crates and their transitive workspace dependents, including examples.
+rustfmt, and clippy with warnings denied exactly as CI's verify job runs it (the whole workspace with the game's code
+mods, plus the server build when horizon-client is affected); the tests of the touched crates, with the features
+CI's workspace-wide run gives them; the launcher (its own workspace) the same way when CI's launcher job would run
+(tools/ci/rust_changes.py --launcher); crates/horizon-theme/tokens.css against horizon-theme; Cargo.lock changing
+only with a Cargo.toml; the Python tests (always, as in CI) and the public-tree check; and the vanilla harnesses the
+changes can affect, picked as CI's parity job picks them (tools/parity.py --changed). Harnesses run where the
+vanilla data is (a prepared .local/ here, or the Mac mini); elsewhere they are listed for CI.
 Tests select library, binary and integration targets explicitly, followed by doc tests, so unrelated example
 executables are not built and linked again.
 
@@ -43,6 +44,7 @@ if "PARITY_SHARED" not in os.environ and not (ROOT / ".local" / "minecraft").exi
     # A fleet worktree without vanilla data still knows each harness's dependencies.
     os.environ["PARITY_SHARED"] = str(FLEET_SHARED)
 from tools import parity, release_train  # noqa: E402
+from tools.ci import rust_changes  # noqa: E402
 
 RBUILD = Path.home() / "fleet" / "rbuild"
 LINE_LIMIT = 500
@@ -82,9 +84,8 @@ def workspace_rust(path):
 
 
 def launcher_rust(path):
-    """Whether a change to path is built into the launcher (its own workspace)."""
-    return not is_doc(path) and any(path.startswith(p) for p in release_train.LAUNCHER_PATHS) and \
-        path != "launcher/links.json" and not path.startswith("launcher/docs/")
+    """Whether a change to path is built into the launcher (its own workspace): CI's launcher job's own rule."""
+    return rust_changes.needs_launcher([path])
 
 
 def touched_crates(paths, packages):
@@ -268,14 +269,33 @@ def parity_summary(output):
     return text
 
 
+# CI's verify job (.github/workflows/ci.yml): clippy over the whole workspace with the game's code mods, and over the
+# server build (the game without sound or controllers); tests with code mods and mod packaging.
+CI_CLIPPY = "cargo clippy --workspace --all-targets --locked --features horizon-client/mods -- -D warnings"
+CI_CLIPPY_SERVER = "cargo clippy -p horizon-client --all-targets --locked --no-default-features -- -D warnings"
+CI_TEST_FEATURES = "horizon-client/mods,horizon-mods/pack"
+
+
 def mod_features(crates):
-    """Code mods are off by default (docs/mods.md): on wherever horizon-mods is checked, as in CI."""
-    if crates is not None and "horizon-mods" not in crates:
-        return ""
-    features = ["horizon-mods/runtime", "horizon-mods/pack"]
-    if crates is None or "horizon-client" in crates:
+    """The features CI's workspace-wide test run gives these crates (code mods are off by default: docs/mods.md).
+    Cargo unifies features over the packages it builds, so a crate tested alone needs the ones the workspace would
+    have turned on for it: horizon-client's code mods, and horizon-mods' runtime, packaging and index."""
+    if crates is None:
+        return f" --features {CI_TEST_FEATURES}"
+    features = []
+    if "horizon-mods" in crates:
+        features += ["horizon-mods/runtime", "horizon-mods/pack", "horizon-mods/index"]
+    if "horizon-client" in crates:
         features.append("horizon-client/mods")
-    return f" --features {','.join(features)}"
+    return f" --features {','.join(features)}" if features else ""
+
+
+# What horizon-client's full content-root tests load (mod_content_tests.rs). They take minutes on prepared data, so
+# they are #[ignore]d and run here only when one of these changes.
+CONTENT_ROOT = ("crates/horizon-client/src/mod_content", "crates/horizon-client/src/assets.rs",
+                "crates/horizon-client/src/blocks.rs", "crates/horizon-client/src/items.rs", "crates/horizon-items/",
+                "crates/horizon-mods/", "crates/horizon-assets/")
+CONTENT_ROOT_TESTS = "cargo test --locked -p horizon-client --features horizon-client/mods --lib mod_content::tests:: -- --ignored"
 
 
 def plan(args, base, changed, crates_of, libraries, dependencies):
@@ -283,16 +303,18 @@ def plan(args, base, changed, crates_of, libraries, dependencies):
     rust = any(workspace_rust(path) for path in changed)
     launcher = any(launcher_rust(path) for path in changed)
     # The Python tests also hold ROADMAP.md to roadmap/roadmap.toml (tests/test_roadmap.py).
-    python = any(path.endswith(".py") or path.startswith(("tests/", "tools/", "roadmap/")) or path == "ROADMAP.md"
-                 for path in changed)
     crates = touched_crates(changed, crates_of) if rust else []
     # An unrecognised Rust path must not silently skip validation.
     if rust and crates == []:
         crates = None
     selection = "--workspace" if crates is None else " ".join(f"-p {shlex.quote(c)}" for c in crates)
+    # CI's own clippy commands: a crate checked alone gets other features than in CI's workspace-wide run, and an
+    # unused import behind a feature passed here and failed in CI (#1895). Warm, the workspace run costs about what
+    # the touched crates and their dependents did (14-32 s against 14-17 s on the Mac mini, 2026-10-26).
     clippy_crates = dependent_crates(crates, dependencies)
-    clippy_selection = "--workspace" if clippy_crates is None else " ".join(
-        f"-p {shlex.quote(c)}" for c in clippy_crates)
+    clippy = CI_CLIPPY
+    if clippy_crates is None or "horizon-client" in clippy_crates:
+        clippy += f" && {CI_CLIPPY_SERVER}"
     test_skip = None if crates is None or crates else "no crate touched"
     doc_crates = sorted(libraries if crates is None else libraries.intersection(crates))
     doc_selection = "--workspace" if crates is None else " ".join(f"-p {shlex.quote(c)}" for c in doc_crates)
@@ -300,16 +322,18 @@ def plan(args, base, changed, crates_of, libraries, dependencies):
     steps = [
         Step("Cargo.lock", where="git"),
         Step("Public tree", "python3 tools/check_public_tree.py", where="here"),
-        Step("Python tests", "python3 -m unittest discover -s tests", where="here",
-             skip=None if python else "no Python change", summary=unittest_passed),
+        # Always, as in CI: some read the crates, the roadmap or the workflows.
+        Step("Python tests", "python3 -m unittest discover -s tests", where="here", summary=unittest_passed),
         Step("rustfmt", "cargo fmt --all -- --check", skip=None if rust else no_rust),
-        Step("clippy", f"cargo clippy {clippy_selection}{mod_features(clippy_crates)} --all-targets --locked -- -D warnings",
-             skip=None if rust else no_rust),
+        Step("clippy", clippy, skip=None if rust else no_rust),
         Step("tests" + (": workspace" if crates is None else f": {', '.join(crates)}" if crates else ""),
              f"cargo test --locked {selection}{mod_features(crates)} --tests",
              skip=test_skip, summary=tests_passed),
         Step("doc tests", f"cargo test --locked {doc_selection} --doc",
              skip=test_skip or (None if doc_crates else "no library touched"), summary=tests_passed),
+        Step("content root tests", CONTENT_ROOT_TESTS, summary=tests_passed,
+             skip=None if crates is None or any(p.startswith(CONTENT_ROOT) for p in changed)
+             else "content root untouched"),
         Step("tokens.css up to date", "cargo test --locked -p horizon-theme --lib tokens_css_is_up_to_date",
              skip=None if any(p.startswith(("crates/horizon-theme/", "xtask/")) for p in changed)
              else "theme untouched"),
@@ -404,7 +428,7 @@ def run_windows(steps, verbose):
         elif step.name == "rustfmt":
             command = ["cargo", "fmt", "--all", "--", "--check"]
         elif step.name == "clippy":
-            command = ["cargo", "clippy", "--workspace", "--all-targets", "--locked", "--", "-D", "warnings"]
+            command = shlex.split(CI_CLIPPY)  # the server build's clippy runs in CI (Linux)
         elif step.name.startswith("tests"):
             command = shlex.split(step.command)
         elif step.name == "tokens.css up to date":
diff --git a/tools/release_train.py b/tools/release_train.py
index 72d81ce57..ec146f386 100644
--- a/tools/release_train.py
+++ b/tools/release_train.py
@@ -347,7 +347,17 @@ def bullet(pr):
 def known_issues(path=ROOT / "docs" / "known-issues.md"):
     if not path.exists():
         return []
-    return [line.rstrip() for line in path.read_text().splitlines() if line.startswith("- ")]
+    issues = []
+    in_bullet = False
+    for line in path.read_text().splitlines():
+        if line.startswith("- "):
+            issues.append(line.rstrip())
+            in_bullet = True
+        elif in_bullet and line.startswith((" ", "\t")) and line.strip():
+            issues[-1] += " " + line.strip()
+        else:
+            in_bullet = False
+    return issues
 
 
 def line_intro(kind, version, previous):
diff --git a/tools/remote.sh b/tools/remote.sh
new file mode 100755
index 000000000..fa913e7cc
--- /dev/null
+++ b/tools/remote.sh
@@ -0,0 +1,133 @@
+#!/usr/bin/env bash
+# Run a command on a Linux build host (default playhorizon) at a worktree's commit, and get its output back.
+#
+#   tools/remote.sh [--host H] [--name N] [--cpus LIST] [--exclusive] [--jobs J] <worktree> <command...>
+#   tools/remote.sh .claude/worktrees/my-fix cargo test -p horizon-world --lib
+#   tools/remote.sh . python3 tools/parity.py food light
+#   tools/remote.sh --cpus 0-3 --exclusive . python3 tools/perf_bench.py   # a benchmark: CPUs 0-3 to itself
+#   tools/remote.sh --list                          # checkouts on the host, their size and last use
+#   tools/remote.sh --gc [DAYS]                     # remove checkouts unused for DAYS (default 2)
+#
+# The host fetches the commit from GitHub itself: commit and push first (uncommitted changes are not sent, and
+# nothing else leaves this machine: no files, no credentials, no environment). Each name (default: the worktree's
+# folder) keeps one checkout there, ~/remote-work/<name>, with its own target/: the next run checks out the new
+# commit over it, so only what changed rebuilds (sccache shares the registry crates between names). One run per
+# name at a time. The command runs in bash at the checkout's root, niced in the host's CI slice, with the host's
+# toolchains, a virtual screen and scratch homes for the game and launcher. .local/ links to the host's vanilla
+# data; a command that runs harnesses (it names parity, lan_e2e or horizon-prepare) also gets .local/horizon-client,
+# prepared as CI prepares it (tools/ci/vanilla-data.sh). Output streams back and is kept in ~/remote-work/<name>.logs/.
+# What the command leaves running is stopped when it ends; stopping this script stops the command on the host.
+# The exit status is the command's.
+#
+# CPUs: playhorizon's CI runner has CPUs 4-7 (a systemd drop-in pins it, docs/release-flow.md), so runs here get
+# 0-3 by default and never slow a pull request's parity job. A run holds its CPU set's lock shared; --exclusive (a
+# benchmark: name it with --cpus and say so in its pull request) holds it alone, so it starts only when no other run
+# uses those CPUs, and the others wait for it to end. --cpus 4-7 or all compete with CI: only when it is idle.
+#
+# The host is lent by a partner who keeps hypervisor access: never send secrets, tokens or credentials there,
+# and never treat a result from it as a CI result.
+set -euo pipefail
+
+host=playhorizon name="" jobs="" cpus=0-3 exclusive=0
+usage() { sed -n '2,9s/^# \{0,1\}//p' "$0" >&2; exit 2; }
+while [ $# -gt 0 ]; do
+  case $1 in
+    --host) host=$2; shift 2;;
+    --name) name=$2; shift 2;;
+    --jobs) jobs=$2; shift 2;;
+    --cpus) cpus=$2; shift 2;;
+    --exclusive) exclusive=1; shift;;
+    --list) exec ssh "ludovic@$host" 'cd ~/remote-work 2>/dev/null && for d in */; do d=${d%/};
+      printf "%-32s %8s  last used %s\n" "$d" "$(du -sh "$d" 2>/dev/null | cut -f1)" "$(stat -c %y "$d.logs" 2>/dev/null | cut -c1-16)"; done';;
+    --gc) days=${2:-2}; exec ssh "ludovic@$host" "cd ~/remote-work 2>/dev/null || exit 0
+      find . -maxdepth 1 -name '*.logs' -mtime +$days | while read -r logs; do d=\${logs%.logs};
+        flock -n \"\$d.lock\" rm -rf \"\$d\" \"\$logs\" \"\$d.lock\" && echo \"removed \${d#./}\"; done";;
+    -h|--help) usage;;
+    *) break;;
+  esac
+done
+[ $# -ge 2 ] || usage
+tree=$(cd "$1" && git rev-parse --show-toplevel); shift
+sha=$(git -C "$tree" rev-parse HEAD)
+name=${name:-$(basename "$tree")}
+[[ $name =~ ^[A-Za-z0-9._-]+$ ]] || { echo "remote.sh: name '$name' must be letters, digits, . _ -" >&2; exit 2; }
+if ! git -C "$tree" diff --quiet HEAD -- 2>/dev/null; then
+  echo "remote.sh: uncommitted changes in $tree are not sent: the host runs ${sha:0:9}" >&2
+fi
+if [ -z "$(git -C "$tree" branch -r --contains "$sha" 2>/dev/null)" ]; then
+  git -C "$tree" fetch -q origin 2>/dev/null || true
+  [ -n "$(git -C "$tree" branch -r --contains "$sha" 2>/dev/null)" ] ||
+    { echo "remote.sh: ${sha:0:9} is not on GitHub yet: push it first (the host fetches from GitHub)" >&2; exit 2; }
+fi
+command=$(printf '%q ' "$@")
+
+# The host side reads its script and these four values on stdin (nothing is re-split by a remote shell); its
+# own environment comes from the runner's files there.
+{
+[[ $cpus =~ ^[0-9,-]+$|^all$ ]] || { echo "remote.sh: --cpus takes a list such as 0-3, or all" >&2; exit 2; }
+printf 'name=%q sha=%q jobs=%q cpus=%q exclusive=%q command=%q\n' "$name" "$sha" "$jobs" "$cpus" "$exclusive" "$command"
+cat <<'REMOTE'
+set -euo pipefail
+if [ "$cpus" = all ]; then pin=(); jobs=${jobs:-$(nproc)}; else pin=(taskset -c "$cpus"); jobs=${jobs:-$(taskset -c "$cpus" nproc)}; fi
+runner=~/.actions-runners/horizon
+if [ -e "$runner/paused" ]; then echo "remote.sh: this host is paused ($runner/paused)" >&2; exit 75; fi
+set -a; . "$runner/.env"; set +a
+export PATH="$(cat "$runner/.path")" DISPLAY=":$(cat "$runner/display")" RUSTC_WRAPPER="$(command -v sccache || true)"
+export CARGO_BUILD_JOBS=$jobs FLEET_LOAD_JOBS=$jobs PARITY_LOCAL_JOBS=$(( jobs > 1 ? jobs / 2 : 1 ))
+unset WAYLAND_DISPLAY
+mkdir -p ~/remote-work && cd ~/remote-work
+exec 9> "$name.lock"
+flock -n 9 || { echo "remote.sh: $name is busy with another run" >&2; exit 75; }
+# The CPU set's lock: shared by ordinary runs, held alone by an --exclusive one (a benchmark).
+exec 8> ".cpus-$cpus.lock"
+if [ "$exclusive" = 1 ]; then
+  flock -x -n 8 || { echo "remote.sh: other runs use CPUs $cpus; try again when they are done (--list)" >&2; exit 75; }
+elif ! flock -s -n 8; then
+  echo "remote.sh: an exclusive run (a benchmark) has CPUs $cpus; waiting for it to end" >&2
+  flock -s 8
+fi
+if [ ! -d "$name/.git" ]; then
+  git clone -q --filter=blob:none --no-checkout https://github.com/ludovic111/horizon "$name" 8>&- 9>&-
+fi
+cd "$name"
+# The lock's descriptor stays out of everything started here (8>&- 9>&-): a daemon one of them starts (sccache's server,
+# from the preparer's build or the command's) would hold the lock after the run.
+git fetch -q --no-tags origin "$sha" 8>&- 9>&-
+git checkout -q --force --detach "$sha"
+git clean -qfd -e /target -e /.local
+# The host's vanilla data, linked as CI's runner links it; for harnesses also .local/horizon-client, prepared by
+# this commit's own preparer (once per preparer version, kept beside the data and shared by every name).
+if [[ $command =~ parity|lan_e2e|horizon-prepare ]]; then
+  RUNNER_WORKSPACE=$(dirname "$HORIZON_SHARED_SOURCE") RUNNER_TEMP=$(mktemp -d) bash tools/ci/vanilla-data.sh >&2 8>&- 9>&-
+else
+  mkdir -p .local
+  for d in minecraft tools datagen; do
+    if [ -e "$HORIZON_SHARED_SOURCE/$d" ]; then ln -sfn "$HORIZON_SHARED_SOURCE/$d" ".local/$d"; fi
+  done
+fi
+scratch=$(mktemp -d)
+trap 'rm -rf "$scratch"' EXIT
+export HORIZON_HOME=$scratch/game HORIZON_LAUNCHER_HOME=$scratch/launcher XDG_DATA_HOME=$scratch/data \
+  XDG_CONFIG_HOME=$scratch/config HORIZON_NO_AUDIO=1 HORIZON_LAUNCHER_NO_SELF_UPDATE=1 HORIZON_TELEMETRY_URL=off
+mkdir -p "$HORIZON_HOME" "$HORIZON_LAUNCHER_HOME" "$XDG_DATA_HOME" "$XDG_CONFIG_HOME" ../"$name.logs"
+log=../"$name.logs/$(date -u +%Y%m%dT%H%M%SZ)-${sha:0:9}.log"
+echo "remote.sh: $(hostname) at ${sha:0:9} in ~/remote-work/$name, CPUs $cpus, -j $jobs; log ~/remote-work/${log#../}" >&2
+# The command runs in a scope of its own, stopped with everything in it once the command is done (a game or a
+# daemon it left behind), when the caller goes away first (the ssh session ends), and before the next run here.
+unit=remote-$name.scope
+systemctl --user stop "$unit" 2>/dev/null || true
+session=$PPID
+( while kill -0 "$session" 2>/dev/null; do sleep 2; done; systemctl --user stop "$unit" 2>/dev/null ) \
+  < /dev/null > /dev/null 2>&1 8>&- 9>&- &
+watcher=$!
+status=0
+systemd-run --user --scope --quiet --slice=horizon-ci.slice --unit="$unit" \
+  "${pin[@]}" nice -n 10 bash -c "$command" 2>&1 < /dev/null 8>&- 9>&- | tee "$log" || status=${PIPESTATUS[0]}
+kill "$watcher" 2>/dev/null || true
+systemctl --user stop "$unit" 2>/dev/null || true
+exit "$status"
+REMOTE
+} | ssh -o BatchMode=yes "ludovic@$host" bash -s &
+# Stopping this script ends the session, and the host then stops the command (above).
+trap 'kill $! 2>/dev/null' INT TERM HUP
+wait $!
diff --git a/tools/test_block_removal_parity.py b/tools/test_block_removal_parity.py
index 3185bd4bb..169806f6e 100755
--- a/tools/test_block_removal_parity.py
+++ b/tools/test_block_removal_parity.py
@@ -180,9 +180,9 @@ def main():
            '-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
     d.run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
            str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
-    d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    d.run(['cargo', 'build', '-q', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
           env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
-    d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
+    d.run([str(lab.cargo_target() / 'fast/horizon-client'), '--resources', str(resources)], cwd=work,
           env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}'))
     # Loot table names (D) are vanilla's bookkeeping; the drops themselves are compared.
     ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
diff --git a/tools/test_command_exec_parity.py b/tools/test_command_exec_parity.py
index 7993a93a7..230e72890 100644
--- a/tools/test_command_exec_parity.py
+++ b/tools/test_command_exec_parity.py
@@ -79,9 +79,9 @@ def main():
     run(['java', '-Xmx3G', '-Duser.timezone=UTC', '-cp', os.pathsep.join([str(classes), str(jars['server']), dependency_path]),
          'dev.horizonlab.parity.VanillaCommandExecOracle', vanilla_dir / 'universe', script_path, build / 'vanilla.jsonl', SEED], 'java', cwd=vanilla_dir)
 
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], 'compile-rust', cwd=lab.ROOT)
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], 'compile-rust', cwd=lab.ROOT)
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     rust_dir = build / 'rust'
     shutil.rmtree(rust_dir, ignore_errors=True)
     rust_dir.mkdir()
diff --git a/tools/test_command_parse_parity.py b/tools/test_command_parse_parity.py
index 620fb548d..8d8007d0d 100644
--- a/tools/test_command_parse_parity.py
+++ b/tools/test_command_parse_parity.py
@@ -64,9 +64,9 @@ def main():
     registries = json.loads((build / 'registries.json').read_text())
     corpus = corpus_module.corpus(tree, registries)
     (build / 'corpus.txt').write_text(''.join(line + '\n' for line in corpus), encoding='utf-8')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
+    binary = Path(metadata['target_directory']) / 'fast/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
     resources = lab.RESOURCES
     total_failures = 0
     summary = []
diff --git a/tools/test_composter_parity.py b/tools/test_composter_parity.py
index 074b227a8..83b99e9b5 100644
--- a/tools/test_composter_parity.py
+++ b/tools/test_composter_parity.py
@@ -122,9 +122,9 @@ def main():
            '-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
     d.run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
            str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
-    d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    d.run(['cargo', 'build', '-q', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
           env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
-    d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
+    d.run([str(lab.cargo_target() / 'fast/horizon-client'), '--resources', str(resources)], cwd=work,
           env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}'))
     ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
     native = h.split_cases((work / 'native.txt').read_text(), ignore)
diff --git a/tools/test_crafter_parity.py b/tools/test_crafter_parity.py
index b9c343d4d..dcb5cd127 100644
--- a/tools/test_crafter_parity.py
+++ b/tools/test_crafter_parity.py
@@ -242,9 +242,9 @@ def main():
            '-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
     d.run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
            str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
-    d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    d.run(['cargo', 'build', '-q', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
           env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
-    d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
+    d.run([str(lab.cargo_target() / 'fast/horizon-client'), '--resources', str(resources)], cwd=work,
           env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}'))
     ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
     native = h.split_cases((work / 'native.txt').read_text(), ignore)
diff --git a/tools/test_dedicated_server_parity.py b/tools/test_dedicated_server_parity.py
index 7572ee3e2..9d7080c7f 100644
--- a/tools/test_dedicated_server_parity.py
+++ b/tools/test_dedicated_server_parity.py
@@ -424,11 +424,11 @@ def main():
     oh.run_logged(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-sourcepath',
                    lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                   build, 'compile-java')
-    oh.run_logged(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
+    oh.run_logged(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
                   'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.RESOURCES, '--dedicated', '--nogui']
 
diff --git a/tools/test_dispenser_parity.py b/tools/test_dispenser_parity.py
index a2c6ba036..729d8e8b7 100644
--- a/tools/test_dispenser_parity.py
+++ b/tools/test_dispenser_parity.py
@@ -417,9 +417,9 @@ def main():
          '-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
     run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
          str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
-    run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    run(['cargo', 'build', '-q', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
         env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
-    run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
+    run([str(lab.cargo_target() / 'fast/horizon-client'), '--resources', str(resources)], cwd=work,
         env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}'))
     # Loot table names (D) are vanilla's bookkeeping; the drops themselves are compared.
     ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
diff --git a/tools/test_enchanting_parity.py b/tools/test_enchanting_parity.py
index 35f0777c8..9e070c3cb 100644
--- a/tools/test_enchanting_parity.py
+++ b/tools/test_enchanting_parity.py
@@ -56,9 +56,9 @@ def main():
         with (build / (name + '.log')).open('w', encoding='utf-8') as log:
             base.run(list(map(str, command)), stdout=log, stderr=subprocess.STDOUT)
     run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none','-sourcepath',str(lab.ROOT/'mods/horizon/src/test/java'), '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
+    binary = Path(metadata['target_directory']) / 'fast/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
     run([binary, 'enchanting_fixture',resources, inputs, build / 'rust.txt'], 'rust')
     references = []
     for side in ['server']:
diff --git a/tools/test_entity_death_loot_parity.py b/tools/test_entity_death_loot_parity.py
index 07c77b0b8..2bb53ebbb 100644
--- a/tools/test_entity_death_loot_parity.py
+++ b/tools/test_entity_death_loot_parity.py
@@ -139,9 +139,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx2G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaEntityDeathLootOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'entity_death_loot_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     errors = [l for l in (build / 'server.txt').read_text().splitlines() if l.startswith('error ')]
     if errors:
diff --git a/tools/test_finalize_spawn_parity.py b/tools/test_finalize_spawn_parity.py
index 7d581fefc..0e889598c 100644
--- a/tools/test_finalize_spawn_parity.py
+++ b/tools/test_finalize_spawn_parity.py
@@ -148,9 +148,9 @@ def main():
         print(f'{len(vanilla)} oracle lines')
         return
     halloween = vanilla[0].split()[1]
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'finalize_spawn_fixture', resources, inputs, build / 'rust.txt', halloween], 'rust')
     rust = (build / 'rust.txt').read_text().splitlines()
     bad = [(a, b) for a, b in zip(vanilla, rust) if a != b]
diff --git a/tools/test_forced_end_parity.py b/tools/test_forced_end_parity.py
new file mode 100755
index 000000000..81a92e4ed
--- /dev/null
+++ b/tools/test_forced_end_parity.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""The End of a dedicated server nobody has entered, force-loaded from the console, against vanilla's.
+
+A vanilla dedicated server and Horizon's each open a copy of one world vanilla generated (its End not made yet).
+With no player online, the console force-loads the End's main island and its arena. A FORCED ticket keeps its level active
+(`ServerChunkCache.hasActiveTickets`, `TicketType.FORCED`), so the chunks are generated, loaded and ticked
+without a player in the dimension. With nobody in the fight, `EnderDragonFight.tick` neither scans the state nor
+places the exit portal: no bedrock and no torches around 0, 0. Both servers must answer the same.
+"""
+import os
+import re
+import subprocess
+import sys
+import time
+
+try:
+    from . import lab, test_rust_parity as base
+    from .test_dedicated_server_parity import Server, wait_ticks
+    from .test_locator_bar_parity import generate_world, server_dir
+except ImportError:
+    import lab
+    import test_rust_parity as base
+    from test_dedicated_server_parity import Server, wait_ticks
+    from test_locator_bar_parity import generate_world, server_dir
+
+NAME = 'forced-end-parity'
+END = 'execute in minecraft:the_end'
+QUERIES = [
+    f'{END} run fill -3 0 -3 3 255 3 minecraft:air replace minecraft:bedrock',
+    f'{END} run fill -3 0 -3 3 255 3 minecraft:air replace minecraft:wall_torch',
+]
+
+
+def answer(server, command, n):
+    start = len(server.lines)
+    server.console(command)
+    server.console(f'say done {n}')
+    server.wait_for(rf'\[Server\] done {n}$', timeout=120)
+    replies = [l.split(']: ', 1)[-1] for l in server.lines[start:] if 'done ' not in l]
+    return ' / '.join(r for r in replies if r) or '(no reply)'
+
+
+def run_side(label, command, build, world):
+    directory = build / label
+    server_dir(directory, world)
+    server = Server(command, directory, label)
+    try:
+        server.wait_for(r'Done \(')
+        # The main island's arena (EnderDragonFight.isArenaLoaded: chunks -8..8), in pieces of at most 256 chunks.
+        for area in ('-128 -128 143 -1', '-128 0 143 143'):
+            server.console(f'{END} run forceload add {area}')
+        deadline = time.time() + 600
+        for poll in range(1_000_000):
+            reply = answer(server, f'{END} if loaded 0 0 0', f'loaded {poll}')
+            if 'passed' in reply:
+                break
+            if time.time() > deadline:
+                raise AssertionError(f'{label}: the End centre never loaded')
+            time.sleep(2)
+        wait_ticks(server, 200)
+        return {q: answer(server, q, i) for i, q in enumerate(QUERIES)}
+    finally:
+        server.stop()
+
+
+def main():
+    _, jars, libraries = base.verify_artifacts()
+    build = lab.LOCAL / NAME
+    build.mkdir(parents=True, exist_ok=True)
+    dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
+    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+                   check=True, capture_output=True)
+    binary = lab.cargo_target() / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
+    horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
+    world = generate_world(vanilla_server, build)
+    vanilla = run_side('vanilla', vanilla_server, build, world)
+    horizon = run_side('horizon', horizon_server, build, world)
+    normal = lambda s: re.sub(r'\s+', ' ', s).strip()
+    problems = [f'{q}\n  vanilla: {vanilla[q]}\n  horizon: {horizon[q]}'
+                for q in QUERIES if normal(vanilla[q]) != normal(horizon[q])]
+    if problems:
+        raise AssertionError('the forced End differs:\n' + '\n'.join(problems))
+    print(f'forced End: loaded and ticked with nobody in it, no exit portal, as vanilla ({vanilla[QUERIES[0]]})')
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except AssertionError as error:
+        sys.exit(f'{NAME}: {error}')
diff --git a/tools/test_friends.py b/tools/test_friends.py
index fd3d626a9..763b0b220 100644
--- a/tools/test_friends.py
+++ b/tools/test_friends.py
@@ -137,6 +137,24 @@ def guest_pos(host, name):
     return next(g['position'] for g in guests if g['name'] == name)
 
 
+def open_ground(host, guest, name):
+    """Puts the guest on a cleared, flat floor beside the host and returns where it stands.
+
+    A player new to the world spawns at a random free spot near the world spawn, as in vanilla
+    (`PlayerSpawnFinder`), often against a hill: walking and aiming need known, open ground.
+    Commands, not the control socket: the server has the last word on where the guest stands.
+    """
+    hp = host('status')['player']['position']
+    x, y, z = math.floor(hp[0]) - 6, math.floor(hp[1]), math.floor(hp[2])
+    host(f'command fill {x - 2} {y - 1} {z - 2} {x + 4} {y - 1} {z + 8} minecraft:stone')
+    host(f'command fill {x - 2} {y} {z - 2} {x + 4} {y + 3} {z + 8} minecraft:air')
+    spot = [x + 0.5, float(y), z + 0.5]
+    host(f'command tp {name} {spot[0]} {spot[1]} {spot[2]} 0 0')
+    guest.wait('status', lambda v: math.dist(v['player']['position'], spot) < 0.01 and v['player']['on_ground'], 20,
+               'the guest on its ground')
+    return spot
+
+
 def play_together(host, guest, name, round_index):
     """Chat, movement and blocks seen from both sides."""
     host.wait('lan status', lambda v: any(g['name'] == name and g['placed'] for g in v['guests']), 60,
@@ -150,6 +168,7 @@ def play_together(host, guest, name, round_index):
     guest.wait('status', lambda v: any(f'hello from the host {round_index}' in l for l in v['server']['chat']), 30,
                'host chat on the guest')
     # The guest walks; the host sees it move.
+    open_ground(host, guest, name)
     before = guest_pos(host, name)
     guest('look 0 0')
     guest('key w down')
@@ -167,7 +186,8 @@ def play_together(host, guest, name, round_index):
     guest.wait('status', lambda v: any(math.dist(p, target) < 0.6 for p in v['server']['player_positions']), 20,
                'host movement on the guest')
     # A block the host places, which the guest sees and then breaks.
-    gp = guest('status')['player']['position']
+    gp = guest.wait('status', lambda v: v['player']['on_ground'] and math.hypot(v['player']['velocity'][0],
+                    v['player']['velocity'][2]) < 1e-3, 10, 'the guest standing still')['player']['position']
     feet = [math.floor(gp[0]), math.floor(gp[1]), math.floor(gp[2])]
     block = [feet[0] + 2, feet[1] + 1, feet[2]]
     # Clear the line of sight (the test terrain has hills), then the block at eye level.
diff --git a/tools/test_locator_bar_parity.py b/tools/test_locator_bar_parity.py
index 6574af76e..05f479461 100644
--- a/tools/test_locator_bar_parity.py
+++ b/tools/test_locator_bar_parity.py
@@ -258,12 +258,12 @@ def sides(name):
     subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath',
                     lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                    cwd=lab.ROOT, check=True, capture_output=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.LocatorBarClient']
diff --git a/tools/test_lore_tooltip_parity.py b/tools/test_lore_tooltip_parity.py
index d262a3542..e6869f7e9 100644
--- a/tools/test_lore_tooltip_parity.py
+++ b/tools/test_lore_tooltip_parity.py
@@ -35,7 +35,7 @@ if __name__ == '__main__':
         sources=[
             lab.ROOT / 'crates/horizon-client/src/item_tooltip.rs',
             lab.ROOT / 'crates/horizon-client/src/item_data.rs',
-            lab.ROOT / 'crates/horizon-client/src/text.rs',
-            lab.ROOT / 'crates/horizon-client/src/component.rs',
+            lab.ROOT / 'crates/horizon-client-core/src/text.rs',
+            lab.ROOT / 'crates/horizon-client-core/src/component.rs',
         ],
         expected_lines=len(CASES))
diff --git a/tools/test_mace_parity.py b/tools/test_mace_parity.py
index 578e9e6ee..2ff560b8d 100644
--- a/tools/test_mace_parity.py
+++ b/tools/test_mace_parity.py
@@ -167,9 +167,9 @@ def main():
            '-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
     d.run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
            str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
-    d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    d.run(['cargo', 'build', '-q', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
           env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
-    d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
+    d.run([str(lab.cargo_target() / 'fast/horizon-client'), '--resources', str(resources)], cwd=work,
           env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}'))
     ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
     native = h.split_cases((work / 'native.txt').read_text(), ignore)
diff --git a/tools/test_mob_ai_parity.py b/tools/test_mob_ai_parity.py
index 133deca2d..9d88ca18d 100644
--- a/tools/test_mob_ai_parity.py
+++ b/tools/test_mob_ai_parity.py
@@ -525,7 +525,7 @@ def main():
                                    'dev.horizonlab.parity.VanillaMobAiOracle', inputs, build / 'vanilla.txt', world],
                                   build, 'vanilla', timeout=3600)
     if not args.java_only:
-        command = ['cargo', 'build', '--locked', '--release', '-p', 'horizon-client', '--example', 'client_probe']
+        command = ['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe']
         target, env = lab.cargo_target(), None
         if args.trace:
             target = lab.LOCAL / 'mob-ai-trace-target'
@@ -533,7 +533,7 @@ def main():
             env = dict(os.environ, CARGO_TARGET_DIR=str(target), CARGO_PROFILE_RELEASE_DEBUG='line-tables-only',
                        CARGO_PROFILE_RELEASE_LTO='false', CARGO_PROFILE_RELEASE_CODEGEN_UNITS='16')
         oracle_harness.run_logged(command, build, 'compile-rust', env=env)
-        binary = target / 'release/examples/client_probe'
+        binary = target / 'fast/examples/client_probe'
         oracle_harness.run_logged([binary, 'mob_ai_probe', lab.RESOURCES, inputs, build / 'horizon.txt'], build, 'horizon')
     if args.java_only:
         return
diff --git a/tools/test_mob_attributes_parity.py b/tools/test_mob_attributes_parity.py
index 7fa1df5e6..27f2b238b 100755
--- a/tools/test_mob_attributes_parity.py
+++ b/tools/test_mob_attributes_parity.py
@@ -62,8 +62,8 @@ def main():
             subprocess.run(list(map(str, cmd)), cwd=lab.ROOT, check=True, timeout=3600, stdout=log, stderr=subprocess.STDOUT)
     run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx1G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]), 'dev.horizonlab.parity.VanillaMobAttributesOracle', build / 'vanilla.txt'], 'java')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
-    binary = lab.cargo_target() / 'release/examples/client_probe'
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    binary = lab.cargo_target() / 'fast/examples/client_probe'
     resources = lab.RESOURCES
     run([binary, 'mob_attributes_fixture', resources, build / 'rust.txt'], 'rust')
     vanilla, rust = parse(build / 'vanilla.txt'), parse(build / 'rust.txt')
diff --git a/tools/test_natural_spawn_parity.py b/tools/test_natural_spawn_parity.py
index 50781eca7..bd3eb2540 100644
--- a/tools/test_natural_spawn_parity.py
+++ b/tools/test_natural_spawn_parity.py
@@ -568,9 +568,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx3G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaNaturalSpawnOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'natural_spawn_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     vanilla = (build / 'server.txt').read_text().splitlines()
     errors = [l for l in vanilla if ' error ' in l]
diff --git a/tools/test_online_mode_parity.py b/tools/test_online_mode_parity.py
index 8096efd80..002516896 100644
--- a/tools/test_online_mode_parity.py
+++ b/tools/test_online_mode_parity.py
@@ -351,11 +351,11 @@ def main():
     build.mkdir(parents=True, exist_ok=True)
     report = build / 'report.json'
     report.unlink(missing_ok=True)
-    oh.run_logged(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
+    oh.run_logged(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
                   'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
 
     services = Services()
diff --git a/tools/test_piston_push_parity.py b/tools/test_piston_push_parity.py
new file mode 100644
index 000000000..17f1a257d
--- /dev/null
+++ b/tools/test_piston_push_parity.py
@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""Compare moving-piston push geometry and predicates with pinned vanilla.
+
+`PistonMovingBlockEntity.moveCollidedEntities` decides how far an entity is
+pushed; the movement it describes is `Entity.move(MoverType.PISTON, ...)`, whose
+collision and per-tick limit the game owns. This harness covers the deciding
+half: the movement area, the offset block box, `getMovement` on every face, the
+per-box loop, `moveStuckEntities`' box and `matchesStickyCritera`, and
+`fixEntityWithinPistonBase`.
+"""
+import argparse
+import json
+import os
+from pathlib import Path
+import platform
+import random
+import struct
+import subprocess
+try:
+    from . import lab, test_rust_parity as base
+except ImportError:
+    import lab
+    import test_rust_parity as base
+
+
+def corpus():
+    def f32(v): return struct.pack('>f', float(v)).hex()
+    def f64(v): return struct.pack('>d', float(v)).hex()
+    def box(values): return [f64(v) for v in values]
+    step = [1.0 / 3.0, 0.25, 0.5, 0.75, 1.0]
+    unit = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0]
+    offsets = [[0, 0, 0], [-17, -64, 30000000], [2147483647, -2147483648, -2147483648]]
+    faces = [0, 1, 2, 3, 4, 5]
+    # Progress pairs around the 0.25/0.5/1.0 thresholds the head and the
+    # extended-progress offset change at.
+    progress = [0.0, 0.25, 0.49999997, 0.5, 0.75, 0.99999994, 1.0]
+    entities = [
+        [0.9, 0.0, 0.2, 1.5, 1.8, 0.8],
+        [1.4, 0.0, 0.2, 2.0, 1.8, 0.8],
+        [0.75, 0.0, 0.2, 1.35, 1.8, 0.8],
+        [3.0, 0.0, 0.2, 3.6, 1.8, 0.8],
+        [0.49, 0.0, 0.49, 0.51, 1.8, 0.51],
+        [0.0, 1.0, 0.0, 1.0, 2.8, 1.0],
+    ]
+    for index, position in enumerate(offsets):
+        for direction in faces:
+            for extending in (False, True):
+                for source in (False, True):
+                    for current in progress:
+                        advanced = min(current + 0.5, 1.0)
+                        for entity in entities:
+                            yield {
+                                'pos': position,
+                                'direction': direction,
+                                'extending': extending,
+                                'source': source,
+                                'progress': f32(current),
+                                'new_progress': f32(advanced),
+                                'block_box': box(unit),
+                                'movement_box': box(unit),
+                                'entity': box(entity),
+                                'boxes': [box(unit)],
+                                'sticky_top': f64(0.0),
+                                'reaction': 0,
+                                'on_ground': True,
+                                'supported': False,
+                                'entity_x': f64(entity[0]),
+                                'entity_z': f64(entity[2]),
+                            }
+    # Split boxes, a retracting honey drag with every push reaction, and the
+    # predicate's supported/on-ground corners.
+    for index in range(4000):
+        rng = random.Random(0x50555348 + index)
+        current = rng.choice(progress)
+        advanced = min(current + 0.5, 1.0)
+        count = rng.randint(1, 4)
+        boxes = []
+        for _ in range(count):
+            low = [rng.choice([0.0, 0.25, 0.5]), rng.choice([0.0, 0.5]), rng.choice([0.0, 0.5])]
+            high = [min(v + rng.choice([0.25, 0.5, 1.0]), 1.0) for v in low]
+            boxes.append(box(low + high))
+        yield {
+            'pos': rng.choice(offsets),
+            'direction': rng.randrange(6),
+            'extending': rng.random() < 0.5,
+            'source': rng.random() < 0.5,
+            'progress': f32(current),
+            'new_progress': f32(advanced),
+            'block_box': boxes[0],
+            'movement_box': boxes[rng.randrange(len(boxes))],
+            'entity': box([
+                rng.choice([0.0, 0.49, 0.75, 0.9, 1.4]),
+                rng.choice([0.0, 0.5]),
+                rng.choice([0.0, 0.2, 0.49]),
+                rng.choice([0.51, 1.35, 1.5, 2.0]),
+                rng.choice([1.8, 2.8]),
+                rng.choice([0.51, 0.8, 1.0]),
+            ]),
+            'boxes': boxes,
+            'sticky_top': f64(rng.choice([0.0, 0.5, 0.9375])),
+            'reaction': rng.randrange(5),
+            'on_ground': rng.random() < 0.5,
+            'supported': rng.random() < 0.5,
+            'entity_x': f64(rng.choice([0.0, 0.5, 1.0, 2.0])),
+            'entity_z': f64(rng.choice([0.0, 0.5, 1.0, 2.0])),
+        }
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--prepare', action='store_true')
+    args = parser.parse_args()
+    build = lab.LOCAL / 'rust-piston-push-parity'
+    build.mkdir(parents=True, exist_ok=True)
+    report_path = build / 'report.json'
+    report_path.unlink(missing_ok=True)
+    if args.prepare:
+        lab.prepare()
+    lock, jars, libraries = base.verify_artifacts()
+    oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPistonPushOracle.java'
+    helpers = [oracle.with_name(name + '.java')
+               for name in ['VanillaCollisionOracle', 'VanillaBlockStateCodecOracle', 'VanillaFaceSupportOracle']]
+    sources = [oracle, *helpers, Path(__file__), lab.ROOT / 'tools/test_rust_parity.py', lab.ROOT / 'tools/lab.py',
+               lab.ROOT / 'Cargo.toml', lab.ROOT / 'Cargo.lock',
+               lab.ROOT / 'crates/horizon-core/Cargo.toml', lab.ROOT / 'crates/horizon-world/Cargo.toml',
+               *sorted((lab.ROOT / 'crates/horizon-core/src').rglob('*.rs')),
+               *sorted((lab.ROOT / 'crates/horizon-world/src').rglob('*.rs')),
+               lab.ROOT / 'crates/horizon-world/examples/probe/piston_push_fixture.rs']
+    tested_sources = base.source_hashes(sources)
+    classes = build / 'classes'
+    classes.mkdir(exist_ok=True)
+
+    def run(command, name):
+        with (build / (name + '.log')).open('w', encoding='utf-8') as log:
+            base.run(list(map(str, command)), stdout=log, stderr=subprocess.STDOUT)
+
+    dependency_path = os.pathsep.join(map(str, libraries))
+    run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none',
+         '-sourcepath', str(lab.ROOT / 'mods/horizon/src/test/java'),
+         '-cp', str(jars['server']) + os.pathsep + dependency_path,
+         '-d', classes, oracle, *helpers], 'compile-java')
+
+    def java(side, mode, path):
+        run(['java', '-Xmx512M', '-cp', os.pathsep.join([str(classes), str(jars[side]), dependency_path]),
+             'dev.horizonlab.parity.VanillaPistonPushOracle', mode, path], side + '-' + mode)
+
+    fixtures = list(corpus())
+    inputs = build / 'inputs.txt'
+    inputs.write_text(''.join(json.dumps(value, separators=(',', ':')) + '\n' for value in fixtures), encoding='utf-8')
+    fixture_paths = [inputs]
+    tested_fixtures = base.source_hashes(fixture_paths)
+    run(['cargo', 'build', '--release', '-p', 'horizon-world', '--example', 'world_probe'], 'compile-rust')
+    metadata = json.loads(subprocess.check_output(
+        ['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
+    binary = Path(metadata['target_directory']) / 'release/examples' / ('world_probe.exe' if os.name == 'nt' else 'world_probe')
+    run([binary, 'piston_push_fixture', build], 'rust')
+    references = []
+    for side, jar in jars.items():
+        java(side, side, build)
+        reference = build / f'{side}.txt'
+        matched = base.compare(reference, build / 'rust.txt')
+        references.append({'side': side, 'jar_sha256': lab.digest(jar, 'sha256'),
+                           'output_sha256': lab.digest(reference, 'sha256'), 'matched_output_lines': matched})
+        print(f'{side}: {matched:,} piston-push output lines match Rust', flush=True)
+    base.ensure_sources_unchanged(sources, tested_sources)
+    base.ensure_sources_unchanged(fixture_paths, tested_fixtures)
+    report = {
+        'schema': 1,
+        'minecraft': lock['minecraft']['version'],
+        'manifest_sha1': lock['minecraft']['manifest_sha1'],
+        'platform': platform.platform(),
+        'java': subprocess.check_output(['java', '--version'], text=True).splitlines()[0],
+        'rustc': subprocess.check_output(['rustc', '--version'], text=True).strip(),
+        'fixtures': len(fixtures),
+        'sources_sha256': tested_sources,
+        'fixtures_sha256': tested_fixtures,
+        'rust_output_sha256': lab.digest(build / 'rust.txt', 'sha256'),
+        'references': references,
+        'scope': 'Actual PistonMovingBlockEntity push geometry and predicates: getExtendedProgress, '
+                 'moveByPositionAndProgress, PistonMath.getMovementArea, getMovement on every face, the '
+                 'moveCollidedEntities loop over split shapes with its delta cap and PUSH_OFFSET, the '
+                 'getEntities search box, and moveStuckEntities\' box with matchesStickyCritera for every push '
+                 'reaction. fixEntityWithinPistonBase is covered by unit tests only: it calls '
+                 'Entity.move(MoverType.PISTON, ...) and so needs a live level. Entity selection order, that '
+                 'collision pass, the per-tick 0.51 limit, block behaviour of the moved state and full gameplay '
+                 'remain elsewhere.',
+    }
+    lab.write_json(report_path, report)
+    print(f'Scoped piston-push parity passed: {report_path}')
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/tools/test_raid_parity.py b/tools/test_raid_parity.py
index 4928c9715..6beadf52b 100644
--- a/tools/test_raid_parity.py
+++ b/tools/test_raid_parity.py
@@ -335,9 +335,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx3G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaRaidOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'raid_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     vanilla = (build / 'server.txt').read_text().splitlines()
     errors = [l for l in vanilla if ' error ' in l]
diff --git a/tools/test_recipe_book_parity.py b/tools/test_recipe_book_parity.py
index c25f180ac..291adeb86 100644
--- a/tools/test_recipe_book_parity.py
+++ b/tools/test_recipe_book_parity.py
@@ -5,8 +5,9 @@ Each case runs a sequence of operations on a fresh book: awarding recipes
 (advancement rewards, /recipe give, crafting; special recipes are never
 learnt, and the count is the displays added), taking them back, the client
 having seen a highlighted recipe, the open and filter settings of the four
-book types, and saving and loading the player's recipeBook compound (with
-unknown ids dropped, and a compound missing a list ignored). The Java oracle
+book types (through the serverbound settings packet's codec), and saving and
+loading the player's recipeBook compound (with unknown ids dropped, and a
+compound missing a list ignored). The Java oracle
 (VanillaRecipeBookOracle) drives ServerRecipeBook and its codec;
 examples/probe/recipe_book_fixture drives horizon_client::recipe_book. After each
 operation the count, the known and highlighted recipes, the settings and
@@ -35,6 +36,12 @@ def main():
     ids = sorted('minecraft:' + p.stem for p in (lib.RESOURCES / 'data/minecraft/recipe').glob('*.json'))
     rng = random.Random(args.seed)
     cases = []
+    # Every book and flag combination crosses the wire, then survives a save/load.
+    for book_type in TYPES:
+        for opened in (False, True):
+            for filtering in (False, True):
+                cases.append({'ops': [{'op': 'set', 'type': book_type, 'open': opened,
+                                       'filtering': filtering}, {'op': 'save'}, {'op': 'load'}]})
     for _ in range(args.cases):
         ops, known = [], set()
         for _ in range(rng.randrange(1, 12)):
diff --git a/tools/test_remote_fireball_parity.py b/tools/test_remote_fireball_parity.py
index 7e60ff30a..e77b41124 100644
--- a/tools/test_remote_fireball_parity.py
+++ b/tools/test_remote_fireball_parity.py
@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
-"""A connected client advances ghast fireballs between tracker packets.
+"""A connected client advances ghast fireballs and thrown items between tracker packets.
 
-AbstractHurtingProjectile.tick/applyInertia run on clients as well as servers.
-Like lan_e2e's falling-entity check, sample motion more often than the tracker
-interval; an interpolation-only client stalls for most of that interval.
+AbstractHurtingProjectile.tick/applyInertia run on clients as well as servers, and
+a thrown item ticks itself on the client too. Like lan_e2e's falling-entity check,
+sample motion more often than the tracker interval; an interpolation-only client
+stalls for most of that interval (#1762).
 """
 import json
 import math
@@ -18,15 +19,19 @@ def check_motion(host, guest, out):
     for game in (host, guest):
         game('command', command='gamemode creative')
     tag = 'remote_fireball_parity'
-    host('command', command=f'fill {x + 2} {y + 18} {z - 1} {x + 48} {y + 23} {z + 1} minecraft:air')
+    # A slow fireball (acceleration_power 0.02: under 0.4 blocks a tick, against ~2 by default) stays in the cleared
+    # corridor and in the guest's tracking range for every sample, however many ticks a loaded host takes to answer.
+    host('command', command=f'fill {x + 2} {y + 18} {z - 1} {x + 96} {y + 23} {z + 1} minecraft:air')
     host('command', command=f'summon minecraft:fireball {x + 3.5} {y + 20} {z + 0.5} '
-                            f'{{Tags:["{tag}"],Motion:[0.1d,0.0d,0.0d]}}')
+                            f'{{Tags:["{tag}"],Motion:[0.1d,0.0d,0.0d],acceleration_power:0.02d}}')
     samples = []
     try:
-        for _ in range(8):
-            balls = [p for p in guest('status')['projectiles'] if p['kind'] == 'LargeFireball']
+        # One ctl process for all samples: a ctl process per sample took 10-16 ticks on a loaded runner, by
+        # which time the fireball had left the cleared corridor and exploded.
+        replies = guest.script(['status', 'wait 1'] * 16, every=True)
+        for status in (reply for reply in replies if 'projectiles' in reply):
+            balls = [p for p in status['projectiles'] if p['kind'] == 'LargeFireball']
             samples.append(balls[0]['position'][0] if balls else None)
-            guest.wait(2)
     finally:
         host('command', command=f'kill @e[tag={tag}]')
     seen = [p for p in samples if p is not None]
@@ -36,6 +41,44 @@ def check_motion(host, guest, out):
     return {'positions': samples}
 
 
+def check_thrown(host, guest, out):
+    """A thrown egg, an ender pearl and a wind charge fly on between tracker packets.
+
+    The server sends a thrown item's position every 10 ticks; a client that only
+    eased towards it hung in the air for half a second (#1762). Vanilla's client
+    ticks the projectile itself, as Entity's no-op interpolation handler does.
+    """
+    x, y, z = (math.floor(v) for v in lan.pos_of(guest))
+    for game in (host, guest):
+        game('command', command='gamemode survival')
+    results = {}
+    for item, kind in (('minecraft:egg', 'Egg'), ('minecraft:ender_pearl', 'EnderPearl'),
+                        ('minecraft:wind_charge', 'WindCharge')):
+        # A clear lane along +X at the guest's eye height, with room to fall.
+        host('command', command=f'fill {x + 2} {y - 7} {z - 2} {x + 60} {y - 7} {z + 2} minecraft:stone')
+        host('command', command=f'fill {x + 2} {y - 6} {z - 2} {x + 60} {y + 3} {z + 2} minecraft:air')
+        guest('command', command=f'tp @s {x + 0.5:.2f} {y:.2f} {z + 0.5:.2f}')
+        guest.wait(20)
+        guest('command', command='clear @s')
+        guest('command', command=f'item replace entity @s weapon.mainhand with {item}')
+        guest.wait(10)
+        # The server throws along the rotation it has: let it arrive first.
+        guest.raw('look-at', f'{x + 40:.2f}', f'{y + 1.62:.2f}', f'{z + 0.5:.2f}')
+        guest.wait(5)
+        guest.raw('use-item')
+        samples = []
+        for _ in range(6):
+            shots = [p for p in guest('status')['projectiles'] if p['kind'] == kind]
+            samples.append(shots[0]['position'][0] if shots else None)
+            guest.wait(2)
+        seen = [p for p in samples if p is not None]
+        moves = sum(b != a for a, b in zip(seen, seen[1:]))
+        results[item] = {'positions': samples, 'moves': moves}
+        assert len(seen) >= 4, f'{item} visible in only {len(seen)} samples: {samples}'
+        assert moves >= len(seen) - 2, f'{item} stalled between tracker updates: {samples}'
+    return results
+
+
 def main():
     subprocess.run(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client',
                     '--bin', 'horizon-client', '--bin', 'horizon-ctl'], cwd=lab.ROOT, check=True)
@@ -43,6 +86,7 @@ def main():
         ['cargo', 'metadata', '--format-version', '1', '--no-deps'], cwd=lab.ROOT, text=True))
     ctl = lab.ROOT / metadata['target_directory'] / 'fast' / 'horizon-ctl'
     lan.CHECK_FNS['remote-fireball'] = check_motion
+    lan.CHECK_FNS['remote-thrown'] = check_thrown
     # Use the runner's current display (xvfb on Linux), with fresh isolated homes.
     lan.game_env = lambda _screen, home: lab.game_env(
         HORIZON_HOME=home, HORIZON_TELEMETRY_URL='off')
@@ -53,7 +97,7 @@ def main():
         out = lab.LOCAL / 'remote-fireball-parity' / mode
         out.mkdir(parents=True, exist_ok=True)
         # lan.Game launches each client with lab.game_env and private scratch homes.
-        reports[mode] = lan.run(ctl, out, lab.RESOURCES.resolve(), ['remote-fireball'])
+        reports[mode] = lan.run(ctl, out, lab.RESOURCES.resolve(), ['remote-fireball', 'remote-thrown'])
     lab.write_json(lab.LOCAL / 'remote-fireball-parity' / 'report.json', reports)
     assert all(r['pass'] for mode in reports.values() for r in mode.values()), reports
 
diff --git a/tools/test_resource_pack_parity.py b/tools/test_resource_pack_parity.py
index 2d9ae2a85..a935e0b34 100644
--- a/tools/test_resource_pack_parity.py
+++ b/tools/test_resource_pack_parity.py
@@ -129,7 +129,7 @@ def main():
                                     "Pack discovery, overlays, filters and the resource stacks vanilla merges.",
                                     sources=[lab.ROOT / "crates/horizon-client/src/packs.rs",
                                              lab.ROOT / "crates/horizon-client/src/sound_events.rs",
-                                             lab.ROOT / "crates/horizon-client/src/lang.rs"])
+                                             lab.ROOT / "crates/horizon-client-core/src/lang.rs"])
         total += len(QUERIES)
     print(f"{total} resource pack queries match the pinned client over {len(SELECTIONS)} selections")
 
diff --git a/tools/test_scoreboard_parity.py b/tools/test_scoreboard_parity.py
index b38dfb301..8098ae681 100644
--- a/tools/test_scoreboard_parity.py
+++ b/tools/test_scoreboard_parity.py
@@ -250,9 +250,9 @@ def main():
     inputs = build / 'inputs.jsonl'
     inputs.write_text(''.join(json.dumps(c, ensure_ascii=False) + '\n' for c in chosen), encoding='utf-8')
     run([*oracle, 'run', inputs, build / 'vanilla.jsonl'], 'vanilla')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
+    binary = Path(metadata['target_directory']) / 'fast/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
     run([binary, 'scoreboard_fixture',build / 'registries.json', inputs, build / 'rust.jsonl', build / 'vanilla.jsonl'], 'rust')
     read = lambda p: [json.loads(l) for l in p.read_text(encoding='utf-8').splitlines()]
     vanilla, rust = read(build / 'vanilla.jsonl'), read(build / 'rust.jsonl')
diff --git a/tools/test_sculk_parity.py b/tools/test_sculk_parity.py
index bff5ad5ba..b4195e5c3 100644
--- a/tools/test_sculk_parity.py
+++ b/tools/test_sculk_parity.py
@@ -336,9 +336,9 @@ def main():
                                    'dev.horizonlab.parity.VanillaSculkOracle', inputs, build / 'vanilla.txt'],
                                   build, 'vanilla', timeout=3600)
     if not args.java_only:
-        oracle_harness.run_logged(['cargo', 'build', '--locked', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'],
+        oracle_harness.run_logged(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'],
                                   build, 'compile-rust')
-        oracle_harness.run_logged([lab.cargo_target() / 'release/horizon-client', '--resources', resources], build, 'horizon',
+        oracle_harness.run_logged([lab.cargo_target() / 'fast/horizon-client', '--resources', resources], build, 'horizon',
                                   env=lab.game_env(HORIZON_SCULK_FIXTURE=f'{inputs},{build / "horizon.txt"}'))
     if args.java_only:
         return
diff --git a/tools/test_secure_chat_parity.py b/tools/test_secure_chat_parity.py
index b9062568a..a4f77470f 100644
--- a/tools/test_secure_chat_parity.py
+++ b/tools/test_secure_chat_parity.py
@@ -254,11 +254,11 @@ def main():
     oh.run_logged(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-sourcepath',
                    lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                   build, 'compile-java')
-    oh.run_logged(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
+    oh.run_logged(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
                   'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     java = ['java', '-Xmx1g', '-Duser.timezone=UTC', '-cp', str(classes) + os.pathsep + dependencies,
             'dev.horizonlab.parity.SecureChatClient']
     oh.run_logged([*java, 'keys', build], build, 'keys')
diff --git a/tools/test_server_dimension_players_parity.py b/tools/test_server_dimension_players_parity.py
index ea026a509..887ebb2d7 100644
--- a/tools/test_server_dimension_players_parity.py
+++ b/tools/test_server_dimension_players_parity.py
@@ -118,12 +118,12 @@ def main():
     subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath',
                     lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                    cwd=lab.ROOT, check=True, capture_output=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.LocatorBarClient']
diff --git a/tools/test_server_dragon_parity.py b/tools/test_server_dragon_parity.py
index dc58e851d..563ac788a 100644
--- a/tools/test_server_dragon_parity.py
+++ b/tools/test_server_dragon_parity.py
@@ -101,12 +101,12 @@ def main():
     # SERVER_DRAGON_SIDES=vanilla (or horizon) runs one side and reads the other's last transcript.
     sides = [s for s in os.environ.get('SERVER_DRAGON_SIDES', 'vanilla,horizon').split(',') if s]
     if 'horizon' in sides:
-        subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+        subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                        check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-Duser.timezone=UTC', '-cp', str(classes) + os.pathsep + dependencies,
diff --git a/tools/test_server_entities_parity.py b/tools/test_server_entities_parity.py
index fba196c72..b8c5a7def 100644
--- a/tools/test_server_entities_parity.py
+++ b/tools/test_server_entities_parity.py
@@ -157,12 +157,12 @@ def main():
     # SERVER_ENTITIES_SIDES=vanilla (or horizon) runs one side and reads the other's last transcript.
     sides = [s for s in os.environ.get('SERVER_ENTITIES_SIDES', 'vanilla,horizon').split(',') if s]
     if 'horizon' in sides:
-        subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+        subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                        check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-Duser.timezone=UTC', '-cp', str(classes) + os.pathsep + dependencies,
diff --git a/tools/test_server_knockback_parity.py b/tools/test_server_knockback_parity.py
index 66b75946e..b3c4355ea 100644
--- a/tools/test_server_knockback_parity.py
+++ b/tools/test_server_knockback_parity.py
@@ -334,12 +334,12 @@ def main():
     subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath',
                     lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                    cwd=lab.ROOT, check=True, capture_output=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.KnockbackClient']
diff --git a/tools/test_server_ops_feedback_parity.py b/tools/test_server_ops_feedback_parity.py
index 91854fac6..eb7788545 100644
--- a/tools/test_server_ops_feedback_parity.py
+++ b/tools/test_server_ops_feedback_parity.py
@@ -118,12 +118,12 @@ def main():
     subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath',
                     lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                    cwd=lab.ROOT, check=True, capture_output=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.LocatorBarClient']
diff --git a/tools/test_server_player_sculk_parity.py b/tools/test_server_player_sculk_parity.py
index 33489ad5a..75c89ea44 100644
--- a/tools/test_server_player_sculk_parity.py
+++ b/tools/test_server_player_sculk_parity.py
@@ -8,6 +8,7 @@ hosts: the guest always uses the server-player path.
 import json
 import math
 import subprocess
+import threading
 
 import lab
 import lan_e2e as lan
@@ -43,17 +44,29 @@ def check_walk(host, guest, out, role):
         until(host, lambda: phase(host), lambda s: 'sculk_sensor_phase=inactive' in s)
         player.wait(10)
         assert 'sculk_sensor_phase=inactive' in phase(host), 'setup activated the sensor'
-        player.raw('key', 'w', 'down')
+        # The sensor stays active 30 ticks. Each client samples it every tick from inside one ctl script, so a
+        # runner that answers control requests slowly (frames drawn on the CPU) can't miss that window between
+        # separate requests; the other client samples alongside the walk.
+        probe = f'getblock {sensor[0]} {sensor[1]} {sensor[2]}'
+        other = guest if player is host else host
+        seen = {}
+
+        def watch(viewer, lines):
+            seen[viewer.name] = [r['block'] for r in viewer.script(lines, every=True) if 'block' in r]
+        watcher = threading.Thread(target=watch, args=(other, ['wait 1', probe] * 100))
+        watcher.start()
         try:
-            player.wait(15)
+            watch(player, ['key w down', *['wait 1', probe] * 15, 'key w up', *['wait 1', probe] * 85])
         finally:
             player.raw('key', 'w', 'up')
+            watcher.join()
         moved = {'client': math.dist(lan.pos_of(player), start),
                  'server': math.dist(lan.server_player(host, player)['position'], start)}
         assert all(d > 1 for d in moved.values()), moved
-        for viewer in (host, guest):
-            until(viewer, lambda: phase(viewer), lambda s: 'sculk_sensor_phase=active' in s, ticks=85)
-        return {'moved': moved, 'phase': phase(host)}
+        active = {name: next((i for i, s in enumerate(states) if 'sculk_sensor_phase=active' in s), None)
+                  for name, states in seen.items()}
+        assert len(active) == 2 and all(i is not None for i in active.values()), f'sensor never active: {seen}'
+        return {'moved': moved, 'first_active_sample': active}
     finally:
         player.raw('key', 'w', 'up')
         host('command', command=f'fill {x - 2} {y} {z - 2} {x + 5} {y + 3} {z + 5} minecraft:air')
diff --git a/tools/test_server_player_targets_parity.py b/tools/test_server_player_targets_parity.py
index 263aa4a59..321a39f06 100644
--- a/tools/test_server_player_targets_parity.py
+++ b/tools/test_server_player_targets_parity.py
@@ -169,12 +169,12 @@ def main():
     subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath',
                     lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                    cwd=lab.ROOT, check=True, capture_output=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     import json
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.LocatorBarClient']
diff --git a/tools/test_server_resource_pack_parity.py b/tools/test_server_resource_pack_parity.py
index 0f5d258c6..10965d273 100644
--- a/tools/test_server_resource_pack_parity.py
+++ b/tools/test_server_resource_pack_parity.py
@@ -134,9 +134,9 @@ def main():
     subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-nowarn', '-sourcepath',
                     lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
                    cwd=lab.ROOT, check=True, capture_output=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
-    binary = lab.cargo_target() / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = lab.cargo_target() / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
     client = ['java', '-Xmx1g', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.ServerPackClient']
diff --git a/tools/test_server_world_gen_parity.py b/tools/test_server_world_gen_parity.py
index f55e55809..14da72a6d 100644
--- a/tools/test_server_world_gen_parity.py
+++ b/tools/test_server_world_gen_parity.py
@@ -130,11 +130,11 @@ def main():
     build.mkdir(parents=True, exist_ok=True)
     report = build / 'report.json'
     report.unlink(missing_ok=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
     vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main',
                       'nogui']
diff --git a/tools/test_spawn_loot_parity.py b/tools/test_spawn_loot_parity.py
new file mode 100644
index 000000000..896cfab0e
--- /dev/null
+++ b/tools/test_spawn_loot_parity.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""A vanilla loot chest at spawn has its loot when Horizon opens the world.
+
+Vanilla rolls a container's loot table when a player first opens it
+(`RandomizableContainer.unpackLootTable`). Horizon rolls a loaded container with a loot table
+and no items as its chunk is read from disk (`save::roll_loaded_loot`), so a container nobody
+opens still saves as vanilla wrote it. The loot tables have to be loaded before the first chunks
+are read: the spawn chunks are read while the world opens, and a chest read before the tables
+came out empty, its loot table lost on the next save.
+
+The vanilla 26.3 server writes a flat world with a seeded loot chest beside the world spawn, then
+rolls the chest itself in a copy of that world (`execute if items` unpacks it). Horizon opens the
+untouched world in a new process, so nothing was loaded before the world, and must hold the same
+items in the same slots. Both single-player paths: the default server thread and in-frame.
+
+  test_spawn_loot_parity.py [--bin-dir DIR] [--keep]
+"""
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from test_save_roundtrip_parity import Vanilla  # noqa: E402
+from test_world_reopen_parity import game_env  # noqa: E402
+
+ROOT = Path(__file__).resolve().parent.parent
+RESOURCES = ROOT / '.local' / 'horizon-client' / '26.3'
+RUN = ROOT / '.local' / 'spawn-loot'
+CHEST = (2, -60, 1)
+LOOT = '{LootTable:"minecraft:chests/simple_dungeon",LootTableSeed:42L}'
+MODES = {'server thread': [], 'in-frame': ['--in-frame']}
+
+
+def vanilla_world():
+    """The world with the unopened chest, and what vanilla rolls from it: [(slot, id, count)]."""
+    server = Vanilla(RUN / 'v0')
+    try:
+        server.run('setworldspawn 0 -60 0')
+        server.run('forceload add 0 0')
+        time.sleep(2)
+        server.run('setblock {} {} {} minecraft:chest{}'.format(*CHEST, LOOT))
+        server.run('save-all flush')
+        time.sleep(2)
+    finally:
+        server.stop()
+    shutil.copytree(RUN / 'v0', RUN / 'vv')
+    server = Vanilla(RUN / 'vv')
+    try:
+        server.run('forceload add 0 0')
+        time.sleep(2)
+        server.run('execute if items block {} {} {} container.* *'.format(*CHEST))
+        text = ' '.join(server.run('data get block {} {} {} Items'.format(*CHEST)))
+    finally:
+        server.stop()
+    rolled = []
+    for item in re.finditer(r'\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}', text.split('data:', 1)[-1]):
+        found = item.group(0)
+        count = re.search(r'count: (\d+)', found)
+        rolled.append((int(re.search(r'Slot: (\d+)b', found).group(1)), re.search(r'id: "([^"]+)"', found).group(1),
+                       int(count.group(1)) if count else 1))
+    return sorted(rolled)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('--bin-dir', help='prebuilt horizon-client and horizon-ctl (default: build them with the fast profile)')
+    parser.add_argument('--keep', action='store_true', help='keep the run folder')
+    args = parser.parse_args()
+    bin_dir = Path(args.bin_dir).resolve() if args.bin_dir else None
+    if bin_dir is None:
+        subprocess.run(['cargo', 'build', '--locked', '--profile', 'fast', '-p', 'horizon-client', '--bins'], cwd=ROOT, check=True)
+        bin_dir = ROOT / os.environ.get('CARGO_TARGET_DIR', 'target') / 'fast'
+    shutil.rmtree(RUN, ignore_errors=True)
+    RUN.mkdir(parents=True)
+    expected = vanilla_world()
+    print('vanilla rolls:', expected)
+    if not expected:
+        sys.exit('vanilla rolled nothing from the chest')
+    env, extra = game_env()
+    failures = 0
+    for index, (mode, flags) in enumerate(MODES.items()):
+        folder = RUN / f'h{index}'
+        shutil.copytree(RUN / 'v0' / 'world', folder / 'saves' / 'world')
+        socket = Path(tempfile.mkdtemp(prefix='hzsl')) / 'control.sock'  # sockets need short paths
+
+        def ctl(*words, check=True):
+            result = subprocess.run([str(bin_dir / 'horizon-ctl'), '--socket', str(socket), '--timeout', '600',
+                                     *map(str, words)], cwd=folder, env=env, capture_output=True, text=True)
+            if check and result.returncode:
+                sys.exit(f'horizon-ctl {" ".join(map(str, words))} failed: {result.stdout}{result.stderr}')
+            return json.loads(result.stdout) if result.stdout.strip().startswith('{') else result.stdout
+
+        ctl('launch', '--resources', RESOURCES, '--world', 'world', '--render-distance', '4', *flags, *extra)
+        try:
+            ctl('wait-ready', '300')
+            slots = ctl('container', *CHEST)['slots']
+        finally:
+            ctl('quit', check=False)
+        got = sorted((slot, stack['item'], stack['count']) for slot, stack in enumerate(slots) if stack)
+        ok = got == expected
+        failures += not ok
+        print(f'{mode}: {len(got)} stacks', 'ok' if ok else f'FAIL: {got}')
+    if not args.keep and not failures:
+        shutil.rmtree(RUN, ignore_errors=True)
+    print('spawn loot:', 'PASS' if not failures else f'{failures} FAILED')
+    sys.exit(1 if failures else 0)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tools/test_spawn_rules_parity.py b/tools/test_spawn_rules_parity.py
index 7f9ac07ce..01196b355 100644
--- a/tools/test_spawn_rules_parity.py
+++ b/tools/test_spawn_rules_parity.py
@@ -155,9 +155,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx2G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaSpawnRulesOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'spawn_rules_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     vanilla = (build / 'server.txt').read_text().splitlines()
     errors = [l for l in vanilla if ' error ' in l]
diff --git a/tools/test_spawner_parity.py b/tools/test_spawner_parity.py
index 187e211b7..34f6ec726 100644
--- a/tools/test_spawner_parity.py
+++ b/tools/test_spawner_parity.py
@@ -249,9 +249,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx3G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaNaturalSpawnOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'natural_spawn_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     vanilla = (build / 'server.txt').read_text().splitlines()
     errors = [l for l in vanilla if ' error ' in l]
diff --git a/tools/test_subtitle_parity.py b/tools/test_subtitle_parity.py
index 6baf25570..17c856550 100644
--- a/tools/test_subtitle_parity.py
+++ b/tools/test_subtitle_parity.py
@@ -133,9 +133,9 @@ def main():
          *(PARITY / f'{n}.java' for n in ('ParityFont', 'VanillaSubtitleOracle'))], 'compile-java')
     run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaSubtitleOracle',
          inputs, build / 'vanilla.jsonl'], 'vanilla')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
+    binary = Path(metadata['target_directory']) / 'fast/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
     run([binary, 'subtitle_fixture',resources, inputs, build / 'rust.jsonl'], 'rust')
     vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text(encoding='utf-8').splitlines()]
     rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text(encoding='utf-8').splitlines()]
diff --git a/tools/test_team_rules_parity.py b/tools/test_team_rules_parity.py
index ac66a412b..9d12075ec 100644
--- a/tools/test_team_rules_parity.py
+++ b/tools/test_team_rules_parity.py
@@ -84,9 +84,9 @@ def main():
          PARITY / 'VanillaTeamRulesOracle.java'], 'compile-java')
     run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaTeamRulesOracle',
          inputs, build / 'vanilla.jsonl'], 'vanilla')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
+    binary = Path(metadata['target_directory']) / 'fast/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
     run([binary, 'team_rules_fixture',inputs, build / 'rust.jsonl'], 'rust')
     vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text().splitlines()]
     rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text().splitlines()]
diff --git a/tools/test_trading_parity.py b/tools/test_trading_parity.py
index 46e81f928..9b5581f3b 100644
--- a/tools/test_trading_parity.py
+++ b/tools/test_trading_parity.py
@@ -219,8 +219,8 @@ def main():
     if args.java_only:
         print(f'{len(vanilla)} oracle lines')
         return
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
-    binary = lab.cargo_target() / 'release/examples/client_probe'
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    binary = lab.cargo_target() / 'fast/examples/client_probe'
     run([binary, 'trading_fixture', resources, inputs, build / 'server.txt', build / 'rust.txt'], 'rust')
     rust = (build / 'rust.txt').read_text().splitlines()
     bad = [(a, b) for a, b in zip(vanilla, rust) if a != b]
diff --git a/tools/test_trial_spawner_parity.py b/tools/test_trial_spawner_parity.py
index 7b2412eaa..43d26338a 100644
--- a/tools/test_trial_spawner_parity.py
+++ b/tools/test_trial_spawner_parity.py
@@ -214,9 +214,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx3G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaNaturalSpawnOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'natural_spawn_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     vanilla = (build / 'server.txt').read_text().splitlines()
     errors = [l for l in vanilla if ' error ' in l]
diff --git a/tools/test_use_item_on_parity.py b/tools/test_use_item_on_parity.py
index eabdd04eb..35e1c5515 100644
--- a/tools/test_use_item_on_parity.py
+++ b/tools/test_use_item_on_parity.py
@@ -405,9 +405,9 @@ def main():
            '-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
     d.run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
            str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
-    d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    d.run(['cargo', 'build', '-q', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
           env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
-    d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
+    d.run([str(lab.cargo_target() / 'fast/horizon-client'), '--resources', str(resources)], cwd=work,
           env=lab.game_env(HORIZON_DISPENSE_FIXTURE=f'{work / "cases.jsonl"},{work / "rust.txt"}'))
     ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
     native = h.split_cases((work / 'native.txt').read_text(), ignore)
diff --git a/tools/test_user_cache_parity.py b/tools/test_user_cache_parity.py
index 621514cc8..34a7af1f3 100644
--- a/tools/test_user_cache_parity.py
+++ b/tools/test_user_cache_parity.py
@@ -205,11 +205,11 @@ def main():
     build.mkdir(parents=True, exist_ok=True)
     report = build / 'report.json'
     report.unlink(missing_ok=True)
-    subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
+    subprocess.run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
                    check=True, capture_output=True)
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = Path(metadata['target_directory']) / 'fast' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     services = Services()
     discovery = services.url + '/minecraft/client'
     dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
diff --git a/tools/test_vault_parity.py b/tools/test_vault_parity.py
index 5741320d3..00e6422f5 100644
--- a/tools/test_vault_parity.py
+++ b/tools/test_vault_parity.py
@@ -190,9 +190,9 @@ def main():
          '-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
     run(['java', '-Xmx3G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
          'dev.horizonlab.parity.VanillaNaturalSpawnOracle', inputs, build / 'server.txt'], 'server')
-    run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
+    run(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
-    binary = Path(metadata['target_directory']) / 'release/examples/client_probe'
+    binary = Path(metadata['target_directory']) / 'fast/examples/client_probe'
     run([binary, 'natural_spawn_fixture', resources, inputs, build / 'rust.txt'], 'rust')
     vanilla = (build / 'server.txt').read_text().splitlines()
     errors = [l for l in vanilla if ' error ' in l]
diff --git a/tools/test_world_reopen_parity.py b/tools/test_world_reopen_parity.py
index 4ef9a5e87..9487fd1b7 100644
--- a/tools/test_world_reopen_parity.py
+++ b/tools/test_world_reopen_parity.py
@@ -68,14 +68,23 @@ def main():
         return json.loads(result.stdout) if result.stdout.strip().startswith('{') else result.stdout
 
     def carts():
-        found = ctl('status')['carts']
-        return sorted((c['kind'], *(round(v, 1) for v in c['position'])) for c in found)
+        """The loaded minecarts once their list stops changing: on a loaded runner the mineshaft's chunks and their
+        entities keep arriving after the world counts as loaded, so one reading can be short of a cart."""
+        last = None
+        for _ in range(30):
+            found = sorted((c['kind'], *(round(v, 1) for v in c['position'])) for c in ctl('status')['carts'])
+            if found == last:
+                return found
+            last = found
+            ctl('wait', '40')
+        return last
 
     ctl('launch', '--resources', str(RESOURCES), '--world', 'reopen', '--seed', '7', '--creative',
         '--render-distance', '4', *extra)
     failures = 0
     try:
         ctl('wait-ready', '300')
+        ctl('wait-for', 'loaded', '--timeout', '300')  # as after each reopen below
         ctl('command', 'summon minecraft:minecart ~2 ~ ~2')
         ctl('wait', '20')
         expected = carts()
diff --git a/tools/test_world_spawn_parity.py b/tools/test_world_spawn_parity.py
index 00c390005..33bdd4c65 100644
--- a/tools/test_world_spawn_parity.py
+++ b/tools/test_world_spawn_parity.py
@@ -69,10 +69,10 @@ def seeds(count):
     return SEEDS + [rng.randrange(-2**63, 2**63) for _ in range(count)]
 
 
-def target_dir():
+def target_dir(profile='release'):
     metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
                                                   cwd=lab.ROOT, text=True))
-    return Path(metadata['target_directory']) / 'release'
+    return Path(metadata['target_directory']) / profile
 
 
 def origins(build, classes, dependencies, all_seeds):
@@ -134,9 +134,9 @@ def main():
     if args.origins_only:
         sys.exit(1 if origin_diffs else 0)
 
-    oh.run_logged(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
+    oh.run_logged(['cargo', 'build', '--profile', 'fast', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
                   'compile-rust', timeout=3600)
-    binary = target_dir() / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
+    binary = target_dir('fast') / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
     # One worker thread: the chunks decorated in a fixed order (see above).
     vanilla_server = ['java', '-Xmx2g', '-Dmax.bg.threads=1', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
     horizon_server = [binary, '--resources', RESOURCES, '--dedicated', '--nogui']