Merge pull request #4319 from v3nn7/fix/menu-panorama

🤖 Agent: six-face panorama check in horizon-prepare check.rs, rustfmt fix; approved; verify green. Proven on a union of main f99f8feaa with 37 open PRs including this head: pr_ready --quick green for it (fmt, clippy -D warnings incl. the server build, 3077 workspace tests, 20 content-root tests, launcher clippy + 340 tests, 510 Python tests; the one failure is #5570's own new test, not in this PR). CI parity covers the harnesses.
Merge pull request #5612 from Lostpold88/fix/rebound-sneak-heal-latches
2026-11-07 22:43:47 -10:00 · 2026-11-01 02:55:46 +01:00 · 2026-11-01 02:55:42 +01:00 · 2026-11-01 02:48:29 +01:00 · 2026-11-01 02:48:26 +01:00 · 2026-11-01 02:48:22 +01:00
991 changed files with 218198 additions and 10507 deletions
@@ -7,3 +7,4 @@ kacpherek    # added by Ludovic, 2026-10-27
 rdbtCVS      # added by Ludovic, 2026-10-27
 Online5277   # added by Ludovic, 2026-10-27 (his top three by merged pull requests)
 levzzz5154   # added by Ludovic, 2026-10-28 (Horizon Team; author of horizon-mixins)
+Qwerner88880 # added by Ludovic, 2026-10-31 (Discord vladislav_hagen; native-mod hooks)
@@ -9,7 +9,9 @@ permissions:
  actions: write
 jobs:
  cancel:
-    runs-on: ubuntu-latest
+    # One of playhorizon's small runners, out of GitHub's shared pool: no checkout, no code of the pull request
+    # (docs/ci-runners.md). SELF_HOSTED_CI=off: GitHub's runners.
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
    steps:
      - name: Cancel the pull request's unfinished runs
        env:
@@ -1,7 +1,7 @@
 name: checks
 # verify: every pull request and every push to main, on GitHub's runners (the repository is public). It is the
-# check main requires, so it always runs: a skipped job counts as passed, and every run of this workflow must report
-# a real verify. It gathers the python, clippy and tests jobs (a change to docs alone skips their Rust steps).
+# check main requires, so it never has a condition: a skipped job counts as passed, and every run of this workflow
+# must report a real verify (a pull request that changes no Rust finishes it in seconds instead).
 # 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); .github/workflows/parity.yml. Only for a pull
 # request that changes a harness, oracle, probe or the runner: the rest are checked on main by parity-main. A fork's pull
@@ -24,19 +24,32 @@ env:
  HORIZON_TELEMETRY_URL: "off"

 jobs:
-  # verify's checks run as three jobs at once (python, clippy, tests: ~4 min instead of ~8 one after another), and
-  # verify gathers them. A failed job makes its dependents skip, and a skipped required check counts as passed, so
-  # verify runs always() and fails unless all three passed.
-  python:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
+  # One job, not one per check: each job takes a runner from the organisation's shared pool, and with every pull request
+  # and every merge to main starting this workflow, three jobs a run left the pool's queue tens of minutes deep.
+  #
+  # Where: GitHub's runners. With the repository variable SELF_HOSTED_CI=all (for when that pool is full: their 4 CPUs
+  # are about one GitHub runner, docs/ci-runners.md), main's pushes and this repository's own pull requests run on
+  # playhorizon's checks runners (label playhorizon-ci); a fork's pull request never does (and the runners refuse it
+  # themselves). There the build folder persists (CARGO_TARGET_DIR, outside the checkout), so the apt packages,
+  # Python and the Rust cache steps are GitHub's only.
+  verify:
+    runs-on: ${{ vars.SELF_HOSTED_CI == 'all' && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository) && fromJSON('["self-hosted", "linux", "playhorizon-ci"]') || 'ubuntu-latest' }}
+    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: actions/setup-python@v5
+        if: runner.environment == 'github-hosted'
        with:
          python-version: '3.12'
+      - name: Does this pull request need Rust checks?
+        if: github.event_name == 'pull_request'
+        id: rust
+        env:
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: python3 tools/ci/rust_changes.py "$BASE_SHA" "$HEAD_SHA" >> "$GITHUB_OUTPUT"
      # A pull request adds only its own commits to main, so it reads those; main's pushes read every ref's history.
      - name: Keep game artifacts out of Git
        env:
@@ -52,30 +65,20 @@ jobs:
          fi
      - name: Test offline research tooling
        run: python -m unittest discover -s tests -v
-  clippy:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Does this pull request need Rust checks?
-        if: github.event_name == 'pull_request'
-        id: rust
-        env:
-          BASE_SHA: ${{ github.event.pull_request.base.sha }}
-          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
-        run: python3 tools/ci/rust_changes.py "$BASE_SHA" "$HEAD_SHA" >> "$GITHUB_OUTPUT"
      - name: Install Rust toolchain and the ALSA and udev headers the client links against
        if: steps.rust.outputs.required != 'false'
+        env:
+          HOSTED: ${{ runner.environment == 'github-hosted' }}
        run: |
-          sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
+          if [ "$HOSTED" = true ]; then
+            sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
+          fi
          rustup toolchain install stable --profile minimal --component rustfmt --component clippy
-      # Dependencies and the workspace's own check, saved from main's runs (pull requests read main's cache).
+      # Dependencies and the workspace's own build, saved from main's runs (pull requests read main's cache).
      - uses: Swatinem/rust-cache@v2
-        if: steps.rust.outputs.required != 'false'
+        if: steps.rust.outputs.required != 'false' && runner.environment == 'github-hosted'
        with:
-          shared-key: verify-clippy
+          shared-key: verify
          save-if: ${{ github.ref == 'refs/heads/main' }}
      - name: Check formatting and lint
        if: steps.rust.outputs.required != 'false'
@@ -84,32 +87,7 @@ jobs:
          cargo +stable clippy --workspace --all-targets -- -D warnings
          # The server build (released as horizon-engine): the game without sound or controllers.
          cargo +stable clippy -p horizon-client --all-targets --no-default-features -- -D warnings
-  tests:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Does this pull request need Rust checks?
-        if: github.event_name == 'pull_request'
-        id: rust
-        env:
-          BASE_SHA: ${{ github.event.pull_request.base.sha }}
-          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
-        run: python3 tools/ci/rust_changes.py "$BASE_SHA" "$HEAD_SHA" >> "$GITHUB_OUTPUT"
-      - name: Install Rust toolchain and the ALSA and udev headers the client links against
-        if: steps.rust.outputs.required != 'false'
-        run: |
-          sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
-          rustup toolchain install stable --profile minimal
-      # Dependencies and the workspace's own build, saved from main's runs (pull requests read main's cache).
-      - uses: Swatinem/rust-cache@v2
-        if: steps.rust.outputs.required != 'false'
-        with:
-          shared-key: verify
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-      # Libraries, binaries and integration tests, then doc tests: not the ~275 examples, which clippy already
+      # Libraries, binaries and integration tests, then doc tests: not the ~275 examples, which clippy above already
      # type-checks and the parity job builds and runs (they were most of this step's build and link time).
      # cargo test, not nextest: nextest's process per test reloads each binary's shared tables for every test, and on
      # these 4-core runners it was no faster (#4978).
@@ -121,24 +99,12 @@ jobs:
          # prepared vanilla data, so without it they pass at once.
          cargo +stable test --workspace --lib mod_content::tests:: -- --ignored
          cargo +stable test --workspace --doc
-  verify:
-    if: always()
-    needs: [python, clippy, tests]
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    steps:
-      - name: Did python, clippy and tests pass?
-        env:
-          RESULTS: ${{ join(needs.*.result, ' ') }}
-        run: |
-          echo "python, clippy, tests: $RESULTS"
-          for result in $RESULTS; do [ "$result" = success ] || exit 1; done
  # 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
  # alone and break it together (#2059 and the registry ratings did, 2026-10-26).
  launcher:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
+    runs-on: ${{ vars.SELF_HOSTED_CI == 'all' && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository) && fromJSON('["self-hosted", "linux", "playhorizon-ci"]') || 'ubuntu-latest' }}
+    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v4
        with:
@@ -152,12 +118,16 @@ jobs:
        run: python3 tools/ci/rust_changes.py --launcher "$BASE_SHA" "$HEAD_SHA" >> "$GITHUB_OUTPUT"
      - name: Install Rust and the headers GPUI links against
        if: steps.launcher.outputs.required != 'false'
+        env:
+          HOSTED: ${{ runner.environment == 'github-hosted' }}
        run: |
-          sudo apt-get update && sudo apt-get install -y --no-install-recommends libxkbcommon-x11-dev libwayland-dev \
-            libx11-xcb-dev libfontconfig-dev libvulkan-dev libasound2-dev libudev-dev
+          if [ "$HOSTED" = true ]; then
+            sudo apt-get update && sudo apt-get install -y --no-install-recommends libxkbcommon-x11-dev libwayland-dev \
+              libx11-xcb-dev libfontconfig-dev libvulkan-dev libasound2-dev libudev-dev
+          fi
          rustup toolchain install stable --profile minimal --component rustfmt --component clippy
      - uses: Swatinem/rust-cache@v2
-        if: steps.launcher.outputs.required != 'false'
+        if: steps.launcher.outputs.required != 'false' && runner.environment == 'github-hosted'
        with:
          workspaces: launcher
          shared-key: launcher
@@ -174,7 +144,8 @@ jobs:
  # a harness, an oracle, a probe or the runner, or carries the run-parity label (run-parity.yml, when it is added).
  parity-scope:
    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository
-    runs-on: ubuntu-latest
+    # A git diff of this repository's own branch: one of playhorizon's small runners (docs/ci-runners.md).
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
    outputs:
      run: ${{ steps.scope.outputs.run }}
    steps:
@@ -29,7 +29,8 @@ jobs:
    # the skipped runs of ordinary comments must not cancel a waiting one.
    concurrency:
      group: claim-${{ github.event.issue.number }}
-    runs-on: ubuntu-latest
+    # One of playhorizon's small runners, out of GitHub's shared pool: main's script only (docs/ci-runners.md).
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
    timeout-minutes: 5
    permissions:
      contents: read
@@ -55,7 +56,8 @@ jobs:
        run: python3 tools/ci/claim_command.py command
  release:
    if: github.event_name != 'issue_comment' && github.repository == 'horizon-rust/horizon'
-    runs-on: ubuntu-latest
+    # One of playhorizon's small runners, out of GitHub's shared pool: main's script only (docs/ci-runners.md).
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
    timeout-minutes: 10
    permissions:
      contents: read
@@ -8,6 +8,9 @@ name: launcher
 # feature. The version and the tag are given to the build (HORIZON_LAUNCHER_VERSION, HORIZON_LAUNCHER_TAG): no bump
 # commits.
 # Never marked latest. Pushes to launcher branches only build. RELEASES_PAUSED=1 stops releases.
+# Linux ships two archives of one binary: the .tar.gz the launcher updates itself from, and an
+# AppImage (packaging/linux/appimage.sh) for players without a distribution package, which replaces
+# itself instead (launcher/src/backend.rs).
 # macOS: Apple Silicon, and Intel cross-built for x86_64-apple-darwin on the same runner, its tests and smoke test
 # under Rosetta 2 (#1161). With the repository variable MACOS_SIGN_IDENTITY set, Horizon.app and the .dmg are signed with
 # Developer ID, notarized and stapled, from the runner's signing keychain (packaging/macos/README.md);
@@ -19,7 +22,7 @@ on:
  push:
    branches: [main, launcher, 'launcher-*']
    paths:
-      # Every crate the launcher builds in, as tools/release_train.py's LAUNCHER_PATHS.
+      # Everything the launcher is built and packaged from, as tools/release_train.py's LAUNCHER_PATHS.
      - 'launcher/**'
      - 'crates/horizon-bench/**'
      - 'crates/horizon-friends/**'
@@ -29,6 +32,8 @@ on:
      - 'crates/horizon-release-sign/**'
      - 'crates/horizon-telemetry/**'
      - 'crates/horizon-theme/**'
+      - 'packaging/linux/**'
+      - 'packaging/icons/**'
      - '.github/workflows/launcher.yml'
  schedule:
    - cron: '7-59/10 * * * *'
@@ -161,7 +166,7 @@ jobs:
        if: runner.os == 'Linux'
        run: |
          sudo apt-get update
-          sudo apt-get install -y libxkbcommon-x11-dev libwayland-dev libx11-xcb-dev libfontconfig-dev libvulkan-dev libasound2-dev
+          sudo apt-get install -y libxkbcommon-x11-dev libwayland-dev libx11-xcb-dev libfontconfig-dev libvulkan-dev libasound2-dev patchelf
      - name: Metal shaders compiled now, or at run time without the Metal toolchain
        # GPUI compiles its Metal shaders when it builds; the Mac mini has Xcode without the Metal toolchain
        # (xcodebuild -downloadComponent MetalToolchain), so there they are compiled when the launcher starts.
@@ -254,6 +259,13 @@ jobs:
            DMGBUILD="$RUNNER_TEMP/dmg/bin/dmgbuild" ../packaging/macos/package.sh "$BIN/${{ matrix.binary }}" "$version" out ${{ matrix.mac_arch }}
            rm -rf out/Horizon.app
          else
+            version=${HORIZON_LAUNCHER_VERSION:-$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -1)}
+            if [[ "$RUNNER_OS" == "Linux" ]]; then
+              # The .tar.gz below is what the launcher updates itself from; the AppImage is what a
+              # player downloads and double-clicks, and it replaces itself instead
+              # (packaging/linux/appimage.sh, launcher/src/backend.rs).
+              ../packaging/linux/appimage.sh "$BIN/${{ matrix.binary }}" "$version" out
+            fi
            mkdir -p dist
            cp "$BIN/${{ matrix.binary }}" dist/
            if [[ "${{ matrix.asset }}" == *.tar.gz ]]; then
@@ -0,0 +1,55 @@
+name: native hook stamp
+# Opens a PR that numbers pending fragments after they merge. Only pushes to
+# main run main's own tool; fragments are read as data, not PR code.
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'tools/native-hook-fragments/*.json'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: native-hook-stamp
+  cancel-in-progress: false
+
+jobs:
+  stamp:
+    if: github.repository == 'horizon-rust/horizon'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: main
+          fetch-depth: 0
+      - name: Open a stamp pull request
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          set -eu
+          branch=automation/native-hook-stamp
+          if [ -n "$(gh pr list --state open --head "$branch" --json number --jq '.[0].number // empty')" ]; then
+            echo "A stamp pull request is already open."
+            exit 0
+          fi
+          python3 tools/stamp_native_hooks.py
+          if git diff --quiet; then
+            echo "No fragments to stamp."
+            exit 0
+          fi
+          git config user.name 'github-actions[bot]'
+          git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
+          git checkout -b "$branch"
+          git add -u
+          git commit -m 'Stamp native hook API fragments'
+          if git ls-remote --exit-code --heads origin "$branch" >/dev/null; then
+            git fetch origin "+refs/heads/$branch:refs/remotes/origin/$branch"
+          fi
+          git push --force-with-lease origin "$branch"
+          gh pr create --base main --head "$branch" --title 'Stamp native hook API fragments' --body 'Assign API numbers to the pending native hook fragments. Close and reopen this PR to run CI.'
@@ -19,7 +19,9 @@ jobs:
    concurrency:
      group: overlap-note-${{ github.event.pull_request.number }}
      cancel-in-progress: true
-    runs-on: ubuntu-latest
+    # One of playhorizon's small runners, out of GitHub's shared pool: it runs main's script only (above), so a fork's
+    # pull request runs none of its code there (docs/ci-runners.md). SELF_HOSTED_CI=off: GitHub's runners.
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
    timeout-minutes: 10
    permissions:
      contents: read
@@ -16,7 +16,9 @@ jobs:
  label:
    # Title-only edits change nothing: skip them before a runner starts.
    if: github.event.action != 'edited' || github.event.changes.body != null
-    runs-on: ubuntu-latest
+    # One of playhorizon's small runners, out of GitHub's shared pool: it runs main's script only (above), so a fork's
+    # pull request runs none of its code there (docs/ci-runners.md). SELF_HOSTED_CI=off: GitHub's runners.
+    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "playhorizon-light"]') || 'ubuntu-latest' }}
    timeout-minutes: 5
    permissions:
      contents: read
@@ -21,6 +21,7 @@
 .DS_Store
 # What the client writes to its working directory when run from the repo root.
 /options.txt
+/debug-profile.json
 /horizon.txt
 /horizon-graphics.txt
 /horizon-controller.txt
@@ -68,6 +68,16 @@ unittest discover -s tests`), `mods/horizon/src/test/java/dev/horizonlab/parity/
 `docs/`, `.github/workflows/`. The website (playhorizon.dev) is the private horizon-rust/horizon-site: its build
 reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` and `crates/horizon-theme/tokens.css` from main.

+## Write tests with signal
+
+- Test observable behavior, not words in docs, comments or source. Keep checks for machine-consumed contracts.
+- Use independent expected values or a vanilla oracle; do not derive the answer from the code under test.
+- Test outcomes, not only calls to stubs. Use mocks to isolate behavior, not as the behavior itself.
+- Skip tests of trivial constants, derives and getters, or behavior already covered by another test.
+- Avoid pinning implementation details; a harmless refactor should not break a behavior test.
+- Make slow tests faster without removing cases or weakening their coverage.
+- Never delete parity harnesses or tests that pin vanilla behaviour: they are the spec.
+
 ## Build and test fast

 ```sh
@@ -2,7 +2,7 @@

 Thanks for helping. Horizon is Minecraft: Java Edition 26.3 rewritten in Rust, and the one rule that shapes
 everything is that **it plays exactly like vanilla**. This page is the short version of how we work; questions are
-welcome on [Discord](https://discord.gg/HcTeMZxe5E).
+welcome on [Discord](https://discord.gg/playhorizon).

 This repository holds the game and the launcher, plus the tools, tests and docs that build, check and release them.
 The website (playhorizon.dev) is built in a separate repository from this one's README, `docs/api/` and roadmap. Anything else (videos, Discord and other community material) lives elsewhere.
@@ -113,6 +113,10 @@ it (edited on every push, never repeated): talk to its author in the thread befo
  can see.
 - **Tick "Allow edits by maintainers".** When something small is left (a lint, a rebase, a nit) we push the fixup
  ourselves instead of sending it back to you; only design questions come back.
+- **Once we've pushed to your branch, merge main into it; don't rebase or force-push.** A rebase or force-push
+  replaces our commits with yours and erases the fixes we added (it happened on #5188 and #5203). Tell your agent
+  too: `git merge origin/main`, never `git rebase` or `git push --force` on a branch a maintainer has touched. If
+  our fixes get erased anyway, we finish the work in our own pull request that keeps your commits and credits you.
 - **Tick its kind** in the template: `parity` (Horizon now does what vanilla does), `bug` (a crash or breakage),
  `perf`, `feature` (new for players), `extra` (Horizon-only, off by default), `tooling` or `docs`. A workflow sets
  that label, and area labels (`launcher`, `mobs`, `worldgen`, `rendering`...) from the paths you change.
@@ -136,5 +140,5 @@ new pushes, we add it again.

 ## Talk to us

-[Discord](https://discord.gg/HcTeMZxe5E) for questions and ideas, [issues](https://github.com/horizon-rust/horizon/issues)
+[Discord](https://discord.gg/playhorizon) for questions and ideas, [issues](https://github.com/horizon-rust/horizon/issues)
 for bugs. To take something on, `/claim` its issue ([above](#claim-before-you-start)).
@@ -34,6 +34,17 @@ dependencies = [
 "generic-array",
 ]

+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures 0.2.17",
+]
+
 [[package]]
 name = "ahash"
 version = "0.8.12"
@@ -118,15 +129,6 @@ dependencies = [
 "libc",
 ]

-[[package]]
-name = "arbitrary"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bc62ac97cc33321f50863d514c3bc38a453947a8f9e781137e47c7401020aed"
-dependencies = [
- "derive_arbitrary",
-]
-
 [[package]]
 name = "arboard"
 version = "3.6.1"
@@ -172,6 +174,45 @@ dependencies = [
 "libloading",
 ]

+[[package]]
+name = "asn1-rs"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f43a50ac4fdca5df8e885c21b835997f0a1cdee65494a6847694a98652d9d8"
+dependencies = [
+ "asn1-rs-derive",
+ "asn1-rs-impl",
+ "displaydoc",
+ "nom 7.1.3",
+ "num-traits",
+ "rusticata-macros",
+ "thiserror 2.0.21",
+ "time",
+]
+
+[[package]]
+name = "asn1-rs-derive"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3109e49b1e4909e9db6515a30c633684d68cdeaa252f215214cb4fa1a5bfee2c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "synstructure 0.13.2",
+]
+
+[[package]]
+name = "asn1-rs-impl"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -190,6 +231,12 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"

+[[package]]
+name = "base64ct"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
+
 [[package]]
 name = "bit-set"
 version = "0.10.0"
@@ -204,6 +251,9 @@ name = "bit-vec"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51"
+dependencies = [
+ "serde",
+]

 [[package]]
 name = "bitflags"
@@ -226,6 +276,15 @@ dependencies = [
 "generic-array",
 ]

+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "block2"
 version = "0.5.1"
@@ -310,6 +369,15 @@ dependencies = [
 "serde_json",
 ]

+[[package]]
+name = "cbc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
+dependencies = [
+ "cipher",
+]
+
 [[package]]
 name = "cc"
 version = "1.6.0"
@@ -348,7 +416,18 @@ checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
 dependencies = [
 "cfg-if",
 "cipher",
- "cpufeatures",
+ "cpufeatures 0.2.17",
+]
+
+[[package]]
+name = "chacha20"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.1",
+ "rand_core 0.10.1",
 ]

 [[package]]
@@ -358,7 +437,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"
 dependencies = [
 "aead",
- "chacha20",
+ "chacha20 0.9.1",
 "cipher",
 "poly1305",
 "zeroize",
@@ -395,6 +474,18 @@ dependencies = [
 "error-code",
 ]

+[[package]]
+name = "cms"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b77c319abfd5219629c45c34c89ba945ed3c5e49fcde9d16b6c3885f118a730"
+dependencies = [
+ "const-oid",
+ "der",
+ "spki",
+ "x509-cert",
+]
+
 [[package]]
 name = "cobs"
 version = "0.3.0"
@@ -434,6 +525,12 @@ dependencies = [
 "crossbeam-utils",
 ]

+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
@@ -529,6 +626,15 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "cpufeatures"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "crc32fast"
 version = "1.5.2"
@@ -557,7 +663,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
 "generic-array",
- "rand_core",
+ "rand_core 0.6.4",
 "typenum",
 ]

@@ -580,10 +686,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
 dependencies = [
 "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.2.17",
 "curve25519-dalek-derive",
 "fiat-crypto",
- "rand_core",
+ "rand_core 0.6.4",
 "rustc_version",
 "subtle",
 ]
@@ -606,14 +712,62 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"

 [[package]]
-name = "derive_arbitrary"
-version = "1.5.0"
+name = "data-encoding"
+version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b034bd7d5f032402a2479444dcc6f74e36a03f31854d41680fb240ef682a1ac"
+checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
+
+[[package]]
+name = "der"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
+dependencies = [
+ "const-oid",
+ "der_derive",
+ "flagset",
+ "pem-rfc7468",
+ "zeroize",
+]
+
+[[package]]
+name = "der-parser"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07da5016415d5a3c4dd39b11ed26f915f52fc4e0dc197d87908bc916e51bc1a6"
+dependencies = [
+ "asn1-rs",
+ "displaydoc",
+ "nom 7.1.3",
+ "num-bigint",
+ "num-traits",
+ "rusticata-macros",
+]
+
+[[package]]
+name = "der_derive"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8034092389675178f570469e6c3b0465d3d30b4505c294a6550db47f3c17ad18"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 3.0.6",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "deranged"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e9de72ce2ad1f90dc62fa25f0f430ef85eb4b0d8fa0be4f30373bc40a21d28e"
+
+[[package]]
+name = "des"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffdd80ce8ce993de27e9f063a444a4d53ce8e8db4c1f00cc03af5ad5a9867a1e"
+dependencies = [
+ "cipher",
 ]

 [[package]]
@@ -765,6 +919,12 @@ version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"

+[[package]]
+name = "flagset"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7ac824320a75a52197e8f2d787f6a38b6718bb6897a35142d749af3c0e8f4fe"
+
 [[package]]
 name = "flate2"
 version = "1.1.10"
@@ -914,8 +1074,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
 dependencies = [
 "cfg-if",
+ "js-sys",
 "libc",
 "r-efi 6.0.0",
+ "rand_core 0.10.1",
+ "wasm-bindgen",
 ]

 [[package]]
@@ -1053,6 +1216,12 @@ version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284"

+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
 [[package]]
 name = "hidapi"
 version = "2.6.7"
@@ -1119,6 +1288,15 @@ dependencies = [
 "serde_json",
 ]

+[[package]]
+name = "horizon-chat-filter"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "serde_json",
+ "toml",
+]
+
 [[package]]
 name = "horizon-client"
 version = "0.1.0"
@@ -1133,6 +1311,7 @@ dependencies = [
 "horizon-anticheat",
 "horizon-assets",
 "horizon-bench",
+ "horizon-chat-filter",
 "horizon-client-core",
 "horizon-client-input",
 "horizon-client-render",
@@ -1143,6 +1322,7 @@ dependencies = [
 "horizon-hdr",
 "horizon-items",
 "horizon-mods",
+ "horizon-narrator",
 "horizon-protocol",
 "horizon-server-files",
 "horizon-shader-api",
@@ -1201,6 +1381,7 @@ dependencies = [
 "cpal",
 "flate2",
 "glam",
+ "half",
 "horizon-assets",
 "horizon-bench",
 "horizon-client-core",
@@ -1209,6 +1390,7 @@ dependencies = [
 "horizon-core",
 "horizon-hdr",
 "horizon-items",
+ "horizon-narrator",
 "horizon-protocol",
 "horizon-shader-api",
 "horizon-shaders",
@@ -1226,6 +1408,7 @@ dependencies = [
 "serde_json",
 "sha1",
 "sha2",
+ "smallvec",
 "symphonia",
 "unicode-bidi",
 "ureq",
@@ -1311,6 +1494,18 @@ dependencies = [
 "zip",
 ]

+[[package]]
+name = "horizon-narrator"
+version = "0.1.0"
+dependencies = [
+ "libloading",
+ "log",
+ "objc2 0.6.5",
+ "objc2-app-kit 0.3.2",
+ "objc2-foundation 0.3.2",
+ "windows 0.62.2",
+]
+
 [[package]]
 name = "horizon-port-pack"
 version = "0.1.0"
@@ -1371,14 +1566,23 @@ dependencies = [
 name = "horizon-server"
 version = "0.1.0"
 dependencies = [
+ "ab_glyph",
+ "base64",
 "chrono",
 "horizon-anticheat",
 "horizon-bench",
+ "horizon-chat-filter",
+ "horizon-core",
 "horizon-release-sign",
 "horizon-server-files",
 "libc",
+ "p12-keystore",
+ "png",
+ "rcgen",
+ "rustls",
 "serde",
 "serde_json",
+ "sha1",
 "sha2",
 "toml",
 "toml_edit",
@@ -1416,8 +1620,10 @@ dependencies = [
 name = "horizon-shaders"
 version = "0.1.0"
 dependencies = [
+ "half",
 "horizon-core",
 "naga",
+ "png",
 "zip",
 ]

@@ -1637,6 +1843,7 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
 dependencies = [
+ "block-padding",
 "generic-array",
 ]

@@ -1928,6 +2135,12 @@ dependencies = [
 "libmimalloc-sys",
 ]

+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
 [[package]]
 name = "minisign-verify"
 version = "0.3.0"
@@ -1963,8 +2176,6 @@ checksum = "743fb55ba31b18fb1ecef6bdc9aa2743314978ac084044301a7eee33fb99a20d"
 [[package]]
 name = "naga"
 version = "30.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a616d2fb8c89516ac2723a581f69d6c18576046bed761bd6b305e5618e6ae130"
 dependencies = [
 "arrayvec",
 "bit-set",
@@ -2041,6 +2252,16 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
 [[package]]
 name = "nom"
 version = "8.0.0"
@@ -2050,6 +2271,22 @@ dependencies = [
 "memchr",
 ]

+[[package]]
+name = "num-bigint"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
+
 [[package]]
 name = "num-derive"
 version = "0.4.2"
@@ -2061,6 +2298,15 @@ dependencies = [
 "syn 2.0.119",
 ]

+[[package]]
+name = "num-integer"
+version = "0.1.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -2437,6 +2683,15 @@ dependencies = [
 "objc2-foundation 0.2.2",
 ]

+[[package]]
+name = "oid-registry"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12f40cff3dde1b6087cc5d5f5d4d65712f34016a03ed60e9c08dcc392736b5b7"
+dependencies = [
+ "asn1-rs",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -2498,6 +2753,29 @@ dependencies = [
 "ttf-parser",
 ]

+[[package]]
+name = "p12-keystore"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffb9bf5222606eb712d3bb30e01bc9420545b00859970897e70c682353a034f2"
+dependencies = [
+ "base64",
+ "cbc",
+ "cms",
+ "der",
+ "des",
+ "hex",
+ "hmac",
+ "pkcs12",
+ "pkcs5",
+ "rand",
+ "rc2",
+ "sha1",
+ "sha2",
+ "thiserror 2.0.21",
+ "x509-parser",
+]
+
 [[package]]
 name = "parking_lot"
 version = "0.12.5"
@@ -2521,6 +2799,25 @@ dependencies = [
 "windows-link",
 ]

+[[package]]
+name = "pbkdf2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
+dependencies = [
+ "digest",
+ "hmac",
+]
+
+[[package]]
+name = "pem-rfc7468"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
+dependencies = [
+ "base64ct",
+]
+
 [[package]]
 name = "percent-encoding"
 version = "2.3.2"
@@ -2564,6 +2861,36 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"

+[[package]]
+name = "pkcs12"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "695b3df3d3cc1015f12d70235e35b6b79befc5fa7a9b95b951eab1dd07c9efc2"
+dependencies = [
+ "cms",
+ "const-oid",
+ "der",
+ "digest",
+ "spki",
+ "x509-cert",
+ "zeroize",
+]
+
+[[package]]
+name = "pkcs5"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e847e2c91a18bfa887dd028ec33f2fe6f25db77db3619024764914affe8b69a6"
+dependencies = [
+ "aes",
+ "cbc",
+ "der",
+ "pbkdf2",
+ "scrypt",
+ "sha2",
+ "spki",
+]
+
 [[package]]
 name = "pkg-config"
 version = "0.3.34"
@@ -2615,7 +2942,7 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
 dependencies = [
- "cpufeatures",
+ "cpufeatures 0.2.17",
 "opaque-debug",
 "universal-hash",
 ]
@@ -2656,6 +2983,12 @@ dependencies = [
 "zerovec",
 ]

+[[package]]
+name = "powerfmt"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a6394b9e965e73d0a289ee54f589087e2c676aedf60885baf52c76b771e4958"
+
 [[package]]
 name = "pp-rs"
 version = "0.2.1"
@@ -2725,6 +3058,17 @@ version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"

+[[package]]
+name = "rand"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af"
+dependencies = [
+ "chacha20 0.10.2",
+ "getrandom 0.4.3",
+ "rand_core 0.10.1",
+]
+
 [[package]]
 name = "rand_core"
 version = "0.6.4"
@@ -2734,6 +3078,12 @@ dependencies = [
 "getrandom 0.2.17",
 ]

+[[package]]
+name = "rand_core"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
+
 [[package]]
 name = "range-alloc"
 version = "0.1.5"
@@ -2758,6 +3108,28 @@ dependencies = [
 "objc2-quartz-core 0.3.2",
 ]

+[[package]]
+name = "rc2"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62c64daa8e9438b84aaae55010a93f396f8e60e3911590fcba770d04643fc1dd"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "rcgen"
+version = "0.14.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8774e05a7d0de114588e6a28fe7e71694b82614ed569d86d8b389dfbc98b8ad8"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "time",
+ "x509-parser",
+ "yasna",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.4.1"
@@ -2849,6 +3221,15 @@ dependencies = [
 "semver",
 ]

+[[package]]
+name = "rusticata-macros"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "faf0c4a6ece9950b9abdb62b1cfcf2a68b3b67a10ba445b3bb85be2a293d0632"
+dependencies = [
+ "nom 7.1.3",
+]
+
 [[package]]
 name = "rustix"
 version = "0.38.44"
@@ -2925,6 +3306,15 @@ dependencies = [
 "twox-hash",
 ]

+[[package]]
+name = "salsa20"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
+dependencies = [
+ "cipher",
+]
+
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -2946,6 +3336,17 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"

+[[package]]
+name = "scrypt"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f"
+dependencies = [
+ "pbkdf2",
+ "salsa20",
+ "sha2",
+]
+
 [[package]]
 name = "sctk-adwaita"
 version = "0.10.1"
@@ -3024,7 +3425,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8"
 dependencies = [
 "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.2.17",
 "digest",
 ]

@@ -3035,7 +3436,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
 "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.2.17",
 "digest",
 ]

@@ -3150,7 +3551,7 @@ checksum = "c5482afe85a0b6ce956c945401598dbc527593c77ba51d0a87a586938b1b893a"
 dependencies = [
 "curve25519-dalek",
 "hkdf",
- "rand_core",
+ "rand_core 0.6.4",
 "sha2",
 ]

@@ -3163,6 +3564,16 @@ dependencies = [
 "bitflags 2.13.2",
 ]

+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
@@ -3280,6 +3691,17 @@ dependencies = [
 "unicode-ident",
 ]

+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "synstructure"
 version = "0.14.0"
@@ -3340,6 +3762,36 @@ dependencies = [
 "syn 3.0.6",
 ]

+[[package]]
+name = "time"
+version = "0.3.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134"
+dependencies = [
+ "deranged",
+ "num-conv",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109"
+
+[[package]]
+name = "time-macros"
+version = "0.2.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
 [[package]]
 name = "tiny-skia"
 version = "0.11.4"
@@ -3459,7 +3911,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6"
 dependencies = [
 "memchr",
- "nom",
+ "nom 8.0.0",
 "petgraph",
 ]

@@ -3475,6 +3927,12 @@ version = "2.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "86a801b3cea342a06d468c8710662aa29e5e05e4f5c0d62f00bbb7f2ad7941c2"

+[[package]]
+name = "typed-path"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce898823d8cd0f028662d2f349694b1af0a5cc9be83f1d213a00d3147445e1e"
+
 [[package]]
 name = "typenum"
 version = "1.20.1"
@@ -4523,6 +4981,35 @@ version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"

+[[package]]
+name = "x509-cert"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1301e935010a701ae5f8655edc0ad17c44bad3ac5ce8c39185f75453b720ae94"
+dependencies = [
+ "const-oid",
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "x509-parser"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d43b0f71ce057da06bc0851b23ee24f3f86190b07203dd8f567d0b706a185202"
+dependencies = [
+ "asn1-rs",
+ "data-encoding",
+ "der-parser",
+ "lazy_static",
+ "nom 7.1.3",
+ "oid-registry",
+ "ring",
+ "rusticata-macros",
+ "thiserror 2.0.21",
+ "time",
+]
+
 [[package]]
 name = "xcursor"
 version = "0.3.11"
@@ -4567,6 +5054,16 @@ version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "550a2b930b62486a393c52d5c3b84bff264b28aa437ed64694d31e93b1757af7"

+[[package]]
+name = "yasna"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5f6765e852b9b4dc8e2a76843e4d64d1cea8e79bcde0b6901aea8e7c7f08282"
+dependencies = [
+ "bit-vec",
+ "time",
+]
+
 [[package]]
 name = "yoke"
 version = "0.8.3"
@@ -4587,7 +5084,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "syn 3.0.6",
- "synstructure",
+ "synstructure 0.14.0",
 ]

 [[package]]
@@ -4628,7 +5125,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "syn 3.0.6",
- "synstructure",
+ "synstructure 0.14.0",
 ]

 [[package]]
@@ -4672,18 +5169,18 @@ dependencies = [

 [[package]]
 name = "zip"
-version = "2.4.2"
+version = "9.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fabe6324e908f85a1c52063ce7aa26b68dcb7eb6dbc83a2d148403c9bc3eba50"
+checksum = "1156b39d142a34b999c2310a50455e0cb3760bf7efad0122f796d813bee26ccb"
 dependencies = [
- "arbitrary",
 "crc32fast",
- "crossbeam-utils",
- "displaydoc",
 "flate2",
+ "getrandom 0.4.3",
 "indexmap",
 "memchr",
- "thiserror 2.0.21",
+ "nix",
+ "typed-path",
+ "windows-sys 0.61.2",
 "zopfli",
 ]

@@ -1,8 +1,9 @@
 [workspace]
-exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"]
+exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal", "third_party/naga"]
 members = [
    "crates/horizon-core",
    "crates/horizon-dualsense",
+    "crates/horizon-narrator",
    "crates/horizon-threads",
    "crates/horizon-hdr",
    "crates/horizon-world",
@@ -14,6 +15,7 @@ members = [
    "crates/horizon-items",
    "crates/horizon-server-files",
    "crates/horizon-anticheat",
+    "crates/horizon-chat-filter",
    "crates/horizon-server",
    "crates/horizon-bots",
    "crates/horizon-assets",
@@ -59,6 +61,8 @@ large_enum_variant = "allow"
 # Drop this and the folder once a wgpu release has these fixes.
 [patch.crates-io]
 wgpu-hal = { path = "third_party/wgpu-hal" }
+# naga 30.0.1, with the fixes to its GLSL frontend that shader packs need (THIRD_PARTY_NOTICES.md).
+naga = { path = "third_party/naga" }

 # Line tables keep file:line in backtraces; full debug info made every
 # example and test binary hundreds of megabytes and slow to link.
@@ -111,7 +111,7 @@ What is in progress, what comes next and where to help: [ROADMAP.md](ROADMAP.md)

 ## Contributing

-Issues and pull requests are welcome: read [CONTRIBUTING.md](CONTRIBUTING.md) (vanilla first, small pull requests). Questions: [Discord](https://discord.gg/HcTeMZxe5E). Before a pull request, run the self-check and paste its output:
+Issues and pull requests are welcome: read [CONTRIBUTING.md](CONTRIBUTING.md) (vanilla first, small pull requests). Questions: [Discord](https://discord.gg/playhorizon). Before a pull request, run the self-check and paste its output:

 ```sh
 git config core.hooksPath .githooks
@@ -742,13 +742,13 @@ Open: the GUI Scale is clamped to 2 after a restart under Hyprland, while XWayla

 </details>

-#### AppImage and a Nix flake
+#### A Nix flake

-Install Horizon on any Linux distribution as an AppImage, and on NixOS through a Nix flake.
+Install Horizon on NixOS through a Nix flake.

 <details><summary>Technical</summary>

-A player's idea (#horizon-ideas). An AppImage of the launcher and game from the release workflow, and a flake.nix packaging the release binaries with their runtime libraries (Vulkan loader, X11/Wayland, ALSA), the way horizon-parity's NixOS setup runs them today.
+A player's idea (#horizon-ideas). The launcher's AppImage ships with each launcher release ([packaging/linux/appimage.sh](packaging/linux/appimage.sh)): one file with the libraries GPUI needs, which replaces itself when it updates. A flake.nix packaging the release binaries with their runtime libraries (Vulkan loader, X11/Wayland, ALSA) is still missing, the way horizon-parity's NixOS setup runs them today.

 </details>

@@ -8,6 +8,12 @@ developers, with upstream fixes applied
 [gfx-rs/wgpu#10714](https://github.com/gfx-rs/wgpu/pull/10714)). It is licensed under MIT or
 Apache-2.0; both licenses are in that folder (`LICENSE.MIT`, `LICENSE.APACHE`).

+## naga
+
+`third_party/naga` is [naga](https://github.com/gfx-rs/wgpu) 30.0.1 by the gfx-rs developers, with
+fixes to its GLSL frontend that shader packs need, each applied in the commit that needed it. It is licensed under MIT or Apache-2.0; both licenses
+are in that folder (`LICENSE.MIT`, `LICENSE.APACHE`).
+
 ## Pixelify Sans

 `crates/horizon-theme/fonts/PixelifySans-*.ttf` is [Pixelify Sans](https://github.com/eifetx/Pixelify-Sans)
@@ -23,13 +29,14 @@ the same grid.

 ## AMD FidelityFX SDK (FSR 3.1 frame generation)

-`crates/horizon-client-render/src/gfx/frame_gen/optical_flow.wgsl` is a port to WGSL of the
-optical flow shaders of the [AMD FidelityFX SDK](https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK)
-1.1.4 (`sdk/include/FidelityFX/gpu/opticalflow`, at commit
+`crates/horizon-client-render/src/gfx/frame_gen/optical_flow.wgsl` and `interpolation.wgsl` are
+ports to WGSL of the optical flow and frame interpolation shaders of the
+[AMD FidelityFX SDK](https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK) 1.1.4
+(`sdk/include/FidelityFX/gpu/{opticalflow,frameinterpolation}`, at commit
 [c6efa6bf7f20](https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/tree/c6efa6bf7f2027b3ec94f28578bb5965eabb9e55)),
 and `optical_flow.rs` follows the SDK's `sdk/src/components/opticalflow/ffx_opticalflow.cpp`
 (its passes, their order and their dispatch sizes). Copyright (C) 2024 Advanced Micro Devices,
-Inc., under the MIT license, whose text heads both files. AMD and FidelityFX are AMD's
+Inc., under the MIT license, whose text heads each file. AMD and FidelityFX are AMD's
 trademarks; Horizon is not affiliated with AMD.

 ## Mod loader logos
@@ -0,0 +1,99 @@
+//! Combat: attacks vanilla's client can't send (docs/anticheat.md).
+//!
+//! Vanilla's client sends ServerboundAttackPacket from one place only, `Minecraft.startAttack`, run from
+//! `handleKeybinds` once per client tick. It attacks the entity of the tick's `hitResult`, which
+//! `Minecraft.tick` picks once before the keys are handled, so every attack of one client tick is on the
+//! same entity. And each attack swings the arm (ServerboundPunchPacket) in the same call, so a client
+//! tick never has more attacks than swings: a tick that does comes from a kill aura hiding its swing.
+//! The swing is counted before or after the attack, as older clients behind a version proxy swing
+//! first; a swing without an attack (a miss, a block) is fine.
+
+/// What breaks vanilla's way of attacking.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Foul {
+    /// A client tick with more attacks than swings: how many more.
+    NoSwing(u32),
+    /// A second entity attacked in the same client tick: the first one and this one.
+    TwoTargets(i32, i32),
+}
+
+/// The attacks of the client tick being heard.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Attacks {
+    /// The entity this tick attacked first.
+    target: Option<i32>,
+    attacks: u32,
+    swings: u32,
+}
+
+impl Attacks {
+    /// ServerboundAttackPacket on entity `target`.
+    pub fn attack(&mut self, target: i32) -> Option<Foul> {
+        self.attacks = self.attacks.saturating_add(1);
+        let first = *self.target.get_or_insert(target);
+        (first != target).then_some(Foul::TwoTargets(first, target))
+    }
+
+    /// ServerboundPunchPacket: the arm swung.
+    pub fn swing(&mut self) {
+        self.swings = self.swings.saturating_add(1);
+    }
+
+    /// ServerboundClientTickEndPacket: the tick's attacks are counted, and the next tick picks its
+    /// target again.
+    pub fn tick_end(&mut self) -> Option<Foul> {
+        let unswung = self.attacks.saturating_sub(self.swings);
+        *self = Self::default();
+        (unswung > 0).then_some(Foul::NoSwing(unswung))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_vanilla_tick_is_clean() {
+        let mut a = Attacks::default();
+        // Two clicks in one tick on the same entity, each swung for.
+        for _ in 0..2 {
+            assert_eq!(a.attack(7), None);
+            a.swing();
+        }
+        assert_eq!(a.tick_end(), None);
+        // The next tick may attack another entity, swinging first (an older client).
+        a.swing();
+        assert_eq!(a.attack(8), None);
+        assert_eq!(a.tick_end(), None);
+        // A swing on its own (a miss, a block) is fine.
+        a.swing();
+        assert_eq!(a.tick_end(), None);
+    }
+
+    #[test]
+    fn an_attack_not_swung_for_is_caught() {
+        let mut a = Attacks::default();
+        a.attack(7);
+        assert_eq!(a.tick_end(), Some(Foul::NoSwing(1)));
+        // A swing in the tick before doesn't count for this one.
+        a.swing();
+        a.tick_end();
+        a.attack(7);
+        a.attack(7);
+        a.swing();
+        assert_eq!(a.tick_end(), Some(Foul::NoSwing(1)));
+    }
+
+    #[test]
+    fn two_entities_in_one_tick_are_caught() {
+        let mut a = Attacks::default();
+        a.attack(7);
+        a.swing();
+        assert_eq!(a.attack(8), Some(Foul::TwoTargets(7, 8)));
+        a.swing();
+        // Still against the tick's first target.
+        assert_eq!(a.attack(9), Some(Foul::TwoTargets(7, 9)));
+        a.swing();
+        assert_eq!(a.tick_end(), None);
+    }
+}
@@ -2,17 +2,25 @@
 //! `server.toml`, each player's violation levels, and the rules of the checks. The server's hub
 //! (`horizon_client::lan`) feeds it what players send and carries out what it decides.
 //!
-//! It is off unless the owner turns it on. A check that fails *flags* the player: its violation level
-//! (VL) rises by the flag's weight and falls back by `decay` a second. From `setback` on, the move or
-//! action is cancelled (the player is sent back where the server last had them); from `alert` on,
-//! online operators and the console are told; from `kick` on, the player is disconnected. Nothing bans.
-//! Any threshold at 0 turns that action off.
+//! It is on by default, and so is every check, but only the checks a vanilla client can't trip act on
+//! their own (`combat`); the others log only until they have shown no false positive with real
+//! players (their `setback`, `alert` and `kick` are 0). `enabled = false` turns the anticheat, or one
+//! check, off. A check that fails *flags* the player: its violation level (VL) rises by the flag's
+//! weight and falls back by `decay` a second. From `setback` on, the move or action is cancelled (the
+//! player is sent back where the server last had them); from `alert` on, online operators and the
+//! console are told; from `kick` on, the player is disconnected. A check's kicks are counted per player
+//! across sessions ([`Strikes`]), and the kick that reaches its `ban_after` bans the player instead
+//! (`banned-players.json`, reason "Horizon anticheat: <check>"). Any threshold at 0 turns that action
+//! off.
 //!
 //! The checks are written from vanilla 26.3's own rules and from what cheats are publicly described to
 //! do, never from another anticheat's code.

+use std::collections::BTreeMap;
+
 use serde::{Deserialize, Serialize};

+pub mod combat;
 pub mod prediction;
 pub mod timer;

@@ -24,12 +32,14 @@ pub struct Actions {
    pub kick: f32,
    /// Violation level lost each second.
    pub decay: f32,
+    /// The kick, counting this check's earlier ones for the player, that bans instead; 0: never.
+    pub ban_after: u32,
 }

 macro_rules! checks {
    ($(
        $(#[$doc:meta])*
-        $field:ident: $Check:ident => $Config:ident [$setback:expr, $alert:expr, $kick:expr, $decay:expr] {
+        $field:ident: $Check:ident => $Config:ident [$setback:expr, $alert:expr, $kick:expr, $decay:expr, $ban_after:expr] {
            $( $(#[$xdoc:meta])* $extra:ident: $ty:ty = $default:expr, )*
        }
    )*) => {
@@ -55,6 +65,7 @@ macro_rules! checks {
                pub alert: f32,
                pub kick: f32,
                pub decay: f32,
+                pub ban_after: u32,
                $( $(#[$xdoc])* pub $extra: $ty, )*
            }

@@ -66,13 +77,14 @@ macro_rules! checks {
                        alert: $alert,
                        kick: $kick,
                        decay: $decay,
+                        ban_after: $ban_after,
                        $($extra: $default,)*
                    }
                }
            }
        )*

-        /// `server.toml`'s `[anticheat]`: off by default.
+        /// `server.toml`'s `[anticheat]`: on by default.
        #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
        #[serde(default, deny_unknown_fields)]
        pub struct Config {
@@ -83,16 +95,20 @@ macro_rules! checks {
            pub alert_level: u8,
            /// Every flag, one line each, relative to the server's folder; empty: no file.
            pub log: String,
+            /// The players' kicks by check ([`Strikes`]), relative to the server's folder; empty: kept
+            /// only while the server runs.
+            pub strikes: String,
            $(pub $field: $Config,)*
        }

        impl Default for Config {
            fn default() -> Self {
                Self {
-                    enabled: false,
+                    enabled: true,
                    alerts: true,
                    alert_level: 2,
                    log: "logs/anticheat.log".into(),
+                    strikes: "anticheat-strikes.json".into(),
                    $($field: $Config::default(),)*
                }
            }
@@ -108,7 +124,13 @@ macro_rules! checks {
                match check {
                    $(Check::$Check => {
                        let c = &self.$field;
-                        Actions { setback: c.setback, alert: c.alert, kick: c.kick, decay: c.decay }
+                        Actions {
+                            setback: c.setback,
+                            alert: c.alert,
+                            kick: c.kick,
+                            decay: c.decay,
+                            ban_after: c.ban_after,
+                        }
                    })*
                }
            }
@@ -120,7 +142,8 @@ checks! {
    /// Timer: more client ticks than the server's clock allows (a sped-up game). Vanilla's client ends
    /// every tick with ServerboundClientTickEndPacket, at the server's tick rate; each one spends a tick's
    /// time from a balance that wall-clock time fills, capped so a pause can't be saved up for a burst.
-    timer: Timer => TimerConfig [2.0, 5.0, 20.0, 0.02] {
+    /// It logs only by default; once trusted: `setback = 2`, `alert = 5`, `kick = 20`.
+    timer: Timer => TimerConfig [0.0, 0.0, 0.0, 0.02, 0] {
        /// How far ahead of the clock, in milliseconds, a client may get before it is flagged.
        tolerance_ms: f64 = 300.0,
        /// The most time, in milliseconds, a quiet connection banks for the ticks that follow (a lag
@@ -129,9 +152,13 @@ checks! {
    }

    /// Ground: a move that says it ends on the ground with nothing there to stand on: no-fall (claiming
-    /// the ground to skip fall damage) and walking on water. The claim is always dropped, so vanilla's
-    /// fall damage follows; from `setback` on the player is also sent back.
-    ground: Ground => GroundConfig [5.0, 15.0, 60.0, 2.0] {}
+    /// the ground to skip fall damage) and walking on water. The claim is dropped, so vanilla's
+    /// fall damage follows (the player is never sent back: `setback = 0` makes the check log only), and
+    /// a player that keeps claiming is kicked, then banned at the second kick (`ban_after = 2`). A claim standing still isn't
+    /// judged (no fall to skip). On the official server's first two hours (67 players), every player who
+    /// wasn't flying or walking on water peaked at level 7 (4 claims standing still in one second); the
+    /// ones who were, at 113 to 3749.
+    ground: Ground => GroundConfig [10.0, 15.0, 30.0, 2.0, 2] {}

    /// Prediction: each move played again from the client's own inputs with vanilla's movement code,
    /// and compared (speed, step, fly, jesus...). Each player's client ticks are recorded
@@ -141,11 +168,19 @@ checks! {
    /// setback puts the player back where its moves last agreed. A tick near what the replay can't
    /// play yet (another entity, a block change or abilities the client hadn't seen, a moving piston,
    /// a chunk the client doesn't have, a riptide launch) is excused, and so are the ticks after it
-    /// until the moves agree again.
-    prediction: Prediction => PredictionConfig [5.0, 15.0, 60.0, 2.0] {
+    /// until the moves agree again. It logs only by default; once trusted: `setback = 5`, `alert = 15`,
+    /// `kick = 60`.
+    prediction: Prediction => PredictionConfig [0.0, 0.0, 0.0, 2.0, 0] {
        /// How far, in blocks, a move may land from where the replay puts it.
        tolerance: f64 = 0.03,
    }
+
+    /// Combat: attacks vanilla's client can't send (`combat`): one with no swing after it (a kill aura
+    /// that hides its swing), or a second entity attacked in the same client tick (vanilla attacks the
+    /// one entity under the crosshair, picked once a tick). Each flags once; from `setback` on the
+    /// player's attacks are dropped. A vanilla client never trips it, so it acts by default: the first
+    /// kick warns, the second bans (`ban_after = 2`).
+    combat: Combat => CombatConfig [2.0, 5.0, 20.0, 0.5, 2] {}
 }

 /// How many checks there are.
@@ -194,6 +229,33 @@ impl Config {
    }
 }

+/// How many times each check kicked each player, kept across sessions (`strikes`, a JSON object of
+/// players' UUIDs to check names to counts): the kick that reaches a check's `ban_after` is a ban.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct Strikes(pub BTreeMap<String, BTreeMap<String, u32>>);
+
+impl Strikes {
+    /// Player `uuid` was kicked by `check`: its kicks by it so far, this one included, and whether this
+    /// one bans. A ban starts the count again, so a player an operator pardons is kicked before the
+    /// next ban.
+    pub fn kick(&mut self, uuid: &str, check: Check, ban_after: u32) -> (u32, bool) {
+        let count = self
+            .0
+            .entry(uuid.to_owned())
+            .or_default()
+            .entry(check.name().to_owned())
+            .or_default();
+        *count = count.saturating_add(1);
+        let kicks = *count;
+        let ban = ban_after > 0 && kicks >= ban_after;
+        if ban {
+            *count = 0;
+        }
+        (kicks, ban)
+    }
+}
+
 /// What a flag leads to.
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub struct Verdict {
@@ -219,6 +281,8 @@ pub struct Player {
    pub ground: Option<(u64, f64)>,
    /// The client ticks the prediction plays again (only while it runs).
    pub record: Option<Box<prediction::Record>>,
+    /// The attacks of the client tick being heard.
+    pub attacks: combat::Attacks,
 }

 impl Player {
@@ -262,12 +326,22 @@ mod tests {
    }

    #[test]
-    fn off_by_default_and_without_a_section() {
-        assert!(!Config::default().enabled);
+    fn on_by_default_but_only_combat_and_ground_act() {
        let c = Config::from_server_toml("[server]\nport = 25565\n").unwrap();
        assert_eq!(c, Config::default());
-        assert!(!c.runs(Check::Timer));
-        assert!(!c.runs(Check::Ground));
+        for &check in Check::ALL {
+            assert!(c.runs(check), "{}", check.name());
+            let a = c.actions(check);
+            let acts = [a.setback, a.alert, a.kick] != [0.0; 3];
+            assert_eq!(
+                acts,
+                matches!(check, Check::Combat | Check::Ground),
+                "{}",
+                check.name()
+            );
+        }
+        let off = Config::from_server_toml("[anticheat]\nenabled = false\n").unwrap();
+        assert!(Check::ALL.iter().all(|&check| !off.runs(check)));
    }

    #[test]
@@ -316,6 +390,25 @@ mod tests {
        assert!(v.kick && v.alert);
    }

+    #[test]
+    fn the_kick_that_reaches_ban_after_bans() {
+        let c = Config::default();
+        assert_eq!(c.actions(Check::Combat).ban_after, 2);
+        assert_eq!(c.actions(Check::Prediction).ban_after, 0);
+        let mut s = Strikes::default();
+        assert_eq!(s.kick("a", Check::Combat, 2), (1, false));
+        // Another player, another check: their own counts.
+        assert_eq!(s.kick("b", Check::Combat, 2), (1, false));
+        assert_eq!(s.kick("a", Check::Timer, 2), (1, false));
+        assert_eq!(s.kick("a", Check::Combat, 2), (2, true));
+        // Pardoned, the player is kicked once more before the next ban.
+        assert_eq!(s.kick("a", Check::Combat, 2), (1, false));
+        // 0 never bans; 1 bans at the first kick.
+        assert_eq!(s.kick("c", Check::Timer, 0), (1, false));
+        assert_eq!(s.kick("c", Check::Timer, 0), (2, false));
+        assert_eq!(s.kick("d", Check::Ground, 1), (1, true));
+    }
+
    #[test]
    fn zero_turns_an_action_off() {
        let mut c = on();
@@ -33,9 +33,16 @@ pub enum Change {
    Velocity([f64; 3]),
    /// ClientboundExplodePacket's player knockback, added to the velocity.
    Knockback([f64; 3]),
-    /// ClientboundUpdateAttributesPacket or a mob effect for the player itself: the server's
-    /// attributes and effects, as they are when the replay reaches it.
-    State,
+    /// ClientboundUpdateAttributesPacket for the player itself: the server's attributes as they
+    /// are when the replay reaches it, but for the movement speed's sprint modifier, which the
+    /// client's sprinting decides: `sprint` is whether the packet had it when it carried the
+    /// movement speed (the client takes the modifiers as sent, so a sprint modifier the packet
+    /// lacks is gone while the client sprints), None when it didn't (the client keeps its own).
+    Attributes { sprint: Option<bool> },
+    /// ClientboundUpdateMobEffectPacket or ClientboundRemoveMobEffectPacket for the player itself:
+    /// the server's effects, as they are when the replay reaches it. (Their attribute modifiers
+    /// are the server's: they reach the client as attributes.)
+    Effects,
    /// ClientboundPlayerAbilitiesPacket (a game mode, flight given or taken), or the player's chest
    /// slot (a glider put on or taken off): the replay takes these from the server every tick, so a
    /// tick played before the client had them may be off.
@@ -386,16 +393,16 @@ mod tests {
    fn changes_keep_the_server_tick_that_sent_them() {
        let mut r = Record::default();
        r.changed(3, Change::Velocity([0.0, 0.4, 0.0]));
-        r.changed(5, Change::State);
+        r.changed(5, Change::Effects);
        let all: Vec<_> = r.changes_since(0).unwrap().copied().collect();
        assert_eq!(
            all,
-            [(3, Change::Velocity([0.0, 0.4, 0.0])), (5, Change::State)]
+            [(3, Change::Velocity([0.0, 0.4, 0.0])), (5, Change::Effects)]
        );
        assert_eq!(r.changes_since(1).unwrap().count(), 1);
        assert!(r.changes_since(3).is_none());
        for i in 0..CHANGES_KEPT as u64 {
-            r.changed(6 + i, Change::State);
+            r.changed(6 + i, Change::Effects);
        }
        // The first two are gone.
        assert!(r.changes_since(1).is_none());
@@ -16,6 +16,7 @@ use std::{
    sync::{Arc, Mutex},
 };

+mod component_predicate;
 mod special;
 pub use special::{SpecialKind, SpecialModel};

@@ -628,7 +629,7 @@ pub enum ConditionProperty {
    ExtendedView,
    KeybindDown(String),
    ViewEntity,
-    /// A `component` predicate, evaluated by the host.
+    /// A single `component` predicate; external predicate types use the host.
    Component(Value),
 }
 impl ConditionProperty {
@@ -651,13 +652,7 @@ impl ConditionProperty {
            "minecraft:extended_view" => Self::ExtendedView,
            "minecraft:keybind_down" => Self::KeybindDown(string(required(m, "keybind")?)?),
            "minecraft:view_entity" => Self::ViewEntity,
-            "minecraft:component" => {
-                let predicate = required(m, "predicate")?;
-                if object(predicate)?.len() != 1 {
-                    return Err(err("a single component predicate is expected"));
-                }
-                Self::Component(predicate.clone())
-            }
+            "minecraft:component" => Self::Component(component_predicate::decode(m)?),
            _ => return Err(err("unknown condition property")),
        })
    }
@@ -964,10 +959,14 @@ pub trait ItemEnv {
    fn bundle_fullness(&self, _stack: &StackView, _components: &Components) -> f32 {
        0.0
    }
-    /// `ItemStack.getMaxStackSize` when the prototype has no component.
+    /// Additional component predicate types supplied by the host.
    fn component_matches(&self, _stack: &StackView, _predicate: &Value) -> bool {
        false
    }
+    /// Membership in the level's enchantment registry tags.
+    fn enchantment_in_tag(&self, _enchantment: &str, _tag: &str) -> bool {
+        false
+    }
    fn is_keybind_down(&self, _keybind: &str) -> bool {
        false
    }
@@ -1335,7 +1334,8 @@ impl Resolve<'_> {
            ConditionProperty::KeybindDown(key) => self.env.is_keybind_down(key),
            ConditionProperty::ViewEntity => owner.is_some_and(|o| o.is_view_entity),
            ConditionProperty::Component(predicate) => {
-                self.env.component_matches(self.stack, predicate)
+                component_predicate::matches(predicate, self.components, self.env)
+                    .unwrap_or_else(|| self.env.component_matches(self.stack, predicate))
            }
        }
    }
@@ -0,0 +1,177 @@
+//! Component conditions used by enchantment-dependent item models.
+use super::*;
+
+/// `DataComponentPredicate.singleCodec`: a single predicate's type discriminator
+/// (`predicate`) and its wrapped codec's separate `value` field.
+pub(super) fn decode(m: &Map<String, Value>) -> Result<Value> {
+    let id = component_type(required(m, "predicate")?)?;
+    let mut value = required(m, "value")?.clone();
+    if matches!(
+        id.as_str(),
+        "minecraft:enchantments" | "minecraft:stored_enchantments"
+    ) {
+        let mut entries = Vec::new();
+        for entry in list(&value)? {
+            let mut entry = object(entry)?.clone();
+            if let Some(selector) = get(&entry, "enchantments") {
+                let selector = match selector {
+                    Value::Array(ids) => Value::Array(
+                        ids.iter()
+                            .map(ident)
+                            .map(|r| r.map(Value::String))
+                            .collect::<Result<_>>()?,
+                    ),
+                    Value::String(name) if name.starts_with('#') => {
+                        Value::String(format!("#{}", identifier(&name[1..])?))
+                    }
+                    _ => Value::String(ident(selector)?),
+                };
+                entry.insert("enchantments".into(), selector);
+            }
+            if let Some(levels) = get(&entry, "levels") {
+                let levels = if levels.is_object() {
+                    let mut bounds = Map::new();
+                    for key in ["min", "max"] {
+                        if let Some(n) = get(object(levels)?, key) {
+                            bounds.insert(key.into(), Value::from(int(n)?));
+                        }
+                    }
+                    // MinMaxBounds.Bounds.validateSwappedBoundsInCodec.
+                    if bounds
+                        .get("min")
+                        .and_then(Value::as_i64)
+                        .zip(bounds.get("max").and_then(Value::as_i64))
+                        .is_some_and(|(min, max)| min > max)
+                    {
+                        return Err(err("minimum exceeds maximum"));
+                    }
+                    Value::Object(bounds)
+                } else {
+                    Value::from(int(levels)?)
+                };
+                entry.insert("levels".into(), levels);
+            }
+            entries.push(Value::Object(entry));
+        }
+        value = Value::Array(entries);
+    }
+    Ok(Value::Object(Map::from_iter([(id, value)])))
+}
+
+/// `EnchantmentsPredicate.matches` and `EnchantmentPredicate.containedIn`:
+/// all entries must match; each entry needs one selected, present enchantment
+/// with a matching level. An empty predicate list still needs the component.
+pub(super) fn matches(
+    predicate: &Value,
+    components: &Components,
+    env: &dyn ItemEnv,
+) -> Option<bool> {
+    let (id, expected) = predicate.as_object()?.iter().next()?;
+    if !matches!(
+        id.as_str(),
+        "minecraft:enchantments" | "minecraft:stored_enchantments"
+    ) {
+        return None;
+    }
+    let Some(have) = components.get(id).and_then(Value::as_object) else {
+        return Some(false);
+    };
+    Some(expected.as_array()?.iter().all(|entry| {
+        let Some(entry) = entry.as_object() else {
+            return false;
+        };
+        have.iter().any(|(id, level)| {
+            let level = level.as_i64().unwrap_or(0);
+            let selector = get(entry, "enchantments");
+            let selected = match selector {
+                None => true,
+                Some(Value::String(s)) => s
+                    .strip_prefix('#')
+                    .map_or(s == id, |tag| env.enchantment_in_tag(id, tag)),
+                Some(Value::Array(ids)) => ids.iter().any(|s| s.as_str() == Some(id)),
+                _ => false,
+            };
+            selected
+                && if selector.is_some() {
+                    matches_enchantment(level, get(entry, "levels"))
+                } else {
+                    level_matches(level, get(entry, "levels"))
+                }
+        })
+    }))
+}
+
+/// `EnchantmentPredicate.matchesEnchantment`: a named enchantment needs a
+/// nonzero level even when its bounds accept zero.
+fn matches_enchantment(level: i64, bounds: Option<&Value>) -> bool {
+    level != 0 && level_matches(level, bounds)
+}
+
+/// `MinMaxBounds.Ints.matches`: inclusive bounds, or an exact integer.
+fn level_matches(level: i64, bounds: Option<&Value>) -> bool {
+    match bounds {
+        None => true,
+        Some(Value::Number(n)) => n.as_i64() == Some(level),
+        Some(Value::Object(bounds)) => {
+            get(bounds, "min")
+                .and_then(Value::as_i64)
+                .is_none_or(|min| level >= min)
+                && get(bounds, "max")
+                    .and_then(Value::as_i64)
+                    .is_none_or(|max| level <= max)
+        }
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    struct Tags;
+    impl ItemEnv for Tags {
+        fn enchantment_in_tag(&self, enchantment: &str, tag: &str) -> bool {
+            enchantment == "minecraft:density" && tag == "horizon:mace"
+        }
+    }
+
+    #[test]
+    fn unnamed_predicates_inspect_entries_but_named_ones_require_a_nonzero_level() {
+        let components = Components::from_iter([(
+            "minecraft:enchantments".into(),
+            json!({"minecraft:density":0}),
+        )]);
+        assert_eq!(
+            matches(&json!({"minecraft:enchantments":[{}]}), &components, &NoEnv),
+            Some(true)
+        );
+        assert_eq!(
+            matches(
+                &json!({"minecraft:enchantments":[{"enchantments":"minecraft:density"}]}),
+                &components,
+                &NoEnv
+            ),
+            Some(false)
+        );
+    }
+
+    #[test]
+    fn enchantment_selectors_use_the_hosts_registry_tags() {
+        let condition = json!({"predicate":"enchantments", "value":[
+            {"enchantments":"#horizon:mace", "levels":{"min":3}}
+        ]});
+        let predicate = decode(condition.as_object().unwrap()).unwrap();
+        let mut components = Components::from_iter([(
+            "minecraft:enchantments".into(),
+            json!({"minecraft:density":3}),
+        )]);
+        assert_eq!(matches(&predicate, &components, &Tags), Some(true));
+        assert_eq!(matches(&predicate, &components, &NoEnv), Some(false));
+        components.insert(
+            "minecraft:enchantments".into(),
+            json!({"minecraft:density":2}),
+        );
+        assert_eq!(matches(&predicate, &components, &Tags), Some(false));
+    }
+}
@@ -335,6 +335,177 @@ pub fn quaternion_from_axis_angle(angle: f32, axis: [f32; 3]) -> [f32; 4] {
    [axis[0] * sin, axis[1] * sin, axis[2] * sin, cos]
 }

+/// A JOML `Matrix3f`: `m[column][row]`.
+type Mat3 = [[f32; 3]; 3];
+
+/// `Matrix3f.mul`: `a * b`.
+fn mul3(a: &Mat3, b: &Mat3) -> Mat3 {
+    std::array::from_fn(|c| {
+        std::array::from_fn(|r| fma(a[0][r], b[c][0], fma(a[1][r], b[c][1], a[2][r] * b[c][2])))
+    })
+}
+/// `Matrix3f.transpose`.
+fn transpose3(m: &Mat3) -> Mat3 {
+    std::array::from_fn(|c| std::array::from_fn(|r| m[r][c]))
+}
+/// `Matrix3f.rotate(Quaternionfc)`: `m * R(q)`, without fma.
+fn rotate3(m: &Mat3, q: [f32; 4]) -> Mat3 {
+    let [x, y, z, w] = q;
+    let (w2, x2, y2, z2) = (w * w, x * x, y * y, z * z);
+    let (zw, xy, xz, yw, yz, xw) = (z * w, x * y, x * z, y * w, y * z, x * w);
+    let (zw, xy, xz, yw, yz, xw) = (zw + zw, xy + xy, xz + xz, yw + yw, yz + yz, xw + xw);
+    let rotation = [
+        [w2 + x2 - z2 - y2, xy + zw, xz - yw],
+        [xy - zw, y2 - z2 + w2 - x2, yz + xw],
+        [yw + xz, yz - xw, z2 - y2 - x2 + w2],
+    ];
+    std::array::from_fn(|c| {
+        let rc = rotation[c];
+        std::array::from_fn(|r| m[0][r] * rc[0] + m[1][r] * rc[1] + m[2][r] * rc[2])
+    })
+}
+/// `Quaternionf.mul`: `a * b`.
+fn quaternion_mul(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
+    let ([x, y, z, w], [qx, qy, qz, qw]) = (a, b);
+    [
+        fma(w, qx, fma(x, qw, fma(y, qz, -z * qy))),
+        fma(w, qy, fma(-x, qz, fma(y, qw, z * qx))),
+        fma(w, qz, fma(x, qy, fma(-y, qx, z * qw))),
+        fma(w, qw, fma(-x, qx, fma(-y, qy, -z * qz))),
+    ]
+}
+
+/// `GivensParameters`: the half angle's sine and cosine.
+#[derive(Clone, Copy)]
+struct Givens(f32, f32);
+
+impl Givens {
+    /// `GivensParameters.fromUnnormalized`.
+    fn unnormalized(sin_half: f32, cos_half: f32) -> Self {
+        let inv = 1.0 / (sin_half * sin_half + cos_half * cos_half).sqrt();
+        Self(inv * sin_half, inv * cos_half)
+    }
+    /// `MatrixUtil.PI_4`: `fromPositiveAngle(π / 4)`.
+    fn quarter_pi() -> Self {
+        let half = std::f32::consts::FRAC_PI_4 / 2.0;
+        let sin = joml_sin(half);
+        Self(sin, cos_from_sin(sin, half))
+    }
+    fn inverse(self) -> Self {
+        Self(-self.0, self.1)
+    }
+    fn cos(self) -> f32 {
+        self.1 * self.1 - self.0 * self.0
+    }
+    fn sin(self) -> f32 {
+        2.0 * self.0 * self.1
+    }
+    /// `aroundX/Y/Z(Quaternionf)` (axis 0, 1, 2).
+    fn quaternion(self, axis: usize) -> [f32; 4] {
+        let mut q = [0.0, 0.0, 0.0, self.1];
+        q[axis] = self.0;
+        q
+    }
+    /// `aroundX/Y/Z(Matrix3f)` (axis 0, 1, 2).
+    fn matrix(self, axis: usize) -> Mat3 {
+        let (cos, sin) = (self.cos(), self.sin());
+        let (a, b) = ((axis + 1) % 3, (axis + 2) % 3);
+        let mut m = [[0.0; 3]; 3];
+        m[axis][axis] = 1.0;
+        m[a][a] = cos;
+        m[b][b] = cos;
+        m[a][b] = sin;
+        m[b][a] = -sin;
+        m
+    }
+}
+
+/// `MatrixUtil.approxGivensQuat`.
+fn approx_givens(a11: f32, a12: f32, a22: f32) -> Givens {
+    let g = 3.0 + 2.0 * 2.0f32.sqrt();
+    let (cos_half, sin_half) = (2.0 * (a11 - a22), a12);
+    if g * sin_half * sin_half < cos_half * cos_half {
+        Givens::unnormalized(sin_half, cos_half)
+    } else {
+        Givens::quarter_pi()
+    }
+}
+/// `MatrixUtil.qrGivensQuat`.
+fn qr_givens(a1: f32, a2: f32) -> Givens {
+    let p = f64::from(a1).hypot(f64::from(a2)) as f32;
+    let mut sin_half = if p > 1.0e-6 { a2 } else { 0.0 };
+    let mut cos_half = a1.abs() + if p > 1.0e-6 { p } else { 1.0e-6 };
+    if a1 < 0.0 {
+        std::mem::swap(&mut sin_half, &mut cos_half);
+    }
+    Givens::unnormalized(sin_half, cos_half)
+}
+/// `MatrixUtil.stepJacobi`: the xy, xz then yz pairs, each by
+/// `similarityTransform` (`R^T * m * R`).
+fn step_jacobi(m: &mut Mat3, q: &mut [f32; 4]) {
+    let mut rotate = |m: &mut Mat3, g: Givens, axis: usize| {
+        *q = quaternion_mul(*q, g.quaternion(axis));
+        let r = g.matrix(axis);
+        *m = mul3(&transpose3(&r), &mul3(m, &r));
+    };
+    if m[0][1] * m[0][1] + m[1][0] * m[1][0] > 1.0e-6 {
+        let g = approx_givens(m[0][0], 0.5 * (m[0][1] + m[1][0]), m[1][1]);
+        rotate(m, g, 2);
+    }
+    if m[0][2] * m[0][2] + m[2][0] * m[2][0] > 1.0e-6 {
+        let g = approx_givens(m[0][0], 0.5 * (m[0][2] + m[2][0]), m[2][2]).inverse();
+        rotate(m, g, 1);
+    }
+    if m[1][2] * m[1][2] + m[2][1] * m[2][1] > 1.0e-6 {
+        let g = approx_givens(m[1][1], 0.5 * (m[1][2] + m[2][1]), m[2][2]);
+        rotate(m, g, 0);
+    }
+}
+
+/// `MatrixUtil.svdDecompose(Matrix4fc, ...)`, how `new Transformation(matrix)`
+/// splits a matrix: translation, left rotation, scale, right rotation. The
+/// right rotation diagonalizes `a^T * a` (`eigenvalueJacobi`, 5 steps), then
+/// QR Givens rotations about z, y and x bring `a * R(right)` to the scale.
+pub fn svd_decompose(m: &Mat4) -> ([f32; 3], [f32; 4], [f32; 3], [f32; 4]) {
+    let inv = 1.0 / m.0[3][3];
+    let a: Mat3 = std::array::from_fn(|c| std::array::from_fn(|r| m.0[c][r] * inv));
+    let mut b = mul3(&transpose3(&a), &a);
+    let mut right = [0.0, 0.0, 0.0, 1.0];
+    for _ in 0..5 {
+        step_jacobi(&mut b, &mut right);
+    }
+    right = normalize_quaternion(right);
+    let (x_small, y_small) = (f64::from(b[0][0]) < 1.0e-6, f64::from(b[1][1]) < 1.0e-6);
+    let mut left = [0.0, 0.0, 0.0, 1.0];
+    let mut r = rotate3(&a, right);
+    let mut qr = |r: &mut Mat3, g: Givens, axis: usize| {
+        left = quaternion_mul(left, g.quaternion(axis));
+        *r = mul3(&transpose3(&g.matrix(axis)), r);
+    };
+    let g = if x_small {
+        qr_givens(r[1][1], -r[1][0])
+    } else {
+        qr_givens(r[0][0], r[0][1])
+    };
+    qr(&mut r, g, 2);
+    let g = if x_small {
+        qr_givens(r[2][2], -r[2][0])
+    } else {
+        qr_givens(r[0][0], r[0][2])
+    };
+    qr(&mut r, g.inverse(), 1);
+    let g = if y_small {
+        qr_givens(r[2][2], -r[2][1])
+    } else {
+        qr_givens(r[1][1], r[1][2])
+    };
+    qr(&mut r, g, 0);
+    let scale = [r[0][0], r[1][1], r[2][2]];
+    let translation = std::array::from_fn(|i| m.0[3][i] * inv);
+    let [x, y, z, w] = right;
+    (translation, left, scale, [-x, -y, -z, w])
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -355,6 +526,51 @@ mod tests {
        assert!((m.0[0][1] - 1.0).abs() < 1e-6 && m.0[0][0].abs() < 1e-6);
    }
    #[test]
+    fn svd_decomposes_like_matrix_util() {
+        let bits = |v: &[f32]| v.iter().map(|f| f.to_bits()).collect::<Vec<_>>();
+        let parts = |m: [f32; 16]| {
+            let (t, l, s, r) = svd_decompose(&Mat4::from_row_major(m));
+            [bits(&t), bits(&l), bits(&s), bits(&r)]
+        };
+        // Values from MatrixUtil.svdDecompose on the 26.3 jar.
+        let scaled = [
+            2.0, 0.0, 0.0, 1.0, 0.0, 3.0, 0.0, -2.0, 0.0, 0.0, 0.5, 0.25, 0.0, 0.0, 0.0, 1.0,
+        ];
+        assert_eq!(
+            parts(scaled),
+            [
+                vec![0x3f80_0000u32, 0xc000_0000, 0x3e80_0000],
+                vec![0u32, 0, 0, 0x3f80_0000],
+                vec![0x4000_0000u32, 0x4040_0000, 0x3f00_0000],
+                vec![0x8000_0000u32, 0x8000_0000, 0x8000_0000, 0x3f80_0000],
+            ]
+        );
+        let quarter_turn = [
+            0.0, -1.0, 0.0, 0.5, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0,
+        ];
+        assert_eq!(
+            parts(quarter_turn),
+            [
+                vec![0x3f00_0000u32, 0, 0],
+                vec![0u32, 0, 0x3f35_04f3, 0x3f35_04f3],
+                vec![0x3f7f_ffffu32, 0x3f7f_ffff, 0x3f80_0000],
+                vec![0x8000_0000u32, 0x8000_0000, 0x8000_0000, 0x3f80_0000],
+            ]
+        );
+        let sheared = [
+            1.0, 0.5, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.25, 0.0, 2.0, 3.0, 0.0, 0.0, 0.0, 2.0,
+        ];
+        assert_eq!(
+            parts(sheared),
+            [
+                vec![0u32, 0, 0x3fc0_0000],
+                vec![0x3c03_7010u32, 0x3d38_d722, 0x3ea8_ef95, 0x3f71_60d9],
+                vec![0x3f23_2630u32, 0x3ec6_bdde, 0x3f81_5b1f],
+                vec![0xbcc5_7e11u32, 0xbda8_1e36, 0xbee2_916d, 0x3f64_860a],
+            ]
+        );
+    }
+    #[test]
    fn half_turn_has_exact_zeros_like_joml() {
        let half_turn = 180.0 * (std::f64::consts::PI / 180.0) as f32;
        assert_eq!(quaternion_xyz(0.0, half_turn, 0.0), [0.0, 1.0, 0.0, 0.0]);
@@ -6,6 +6,12 @@
 //! and `force-gamemode=true`): they never touch blocks, so they need no world of their own, and no server
 //! can refuse their moves for walking into terrain. Every behaviour is deterministic from `--seed`.
 //!
+//! `--behaviour fight` is the exception: the bots play in survival (`gamemode=survival`, `force-gamemode=true`,
+//! and `allow-flight=true` because they hold their spawn height instead of standing on terrain they cannot
+//! see). They track the entities the server sends, walk to the nearest living one and attack it at vanilla's
+//! bare-hand cooldown (every 5 ticks). With `--pvp true` (the default) the other bots are targets too, which
+//! hurts only when the server has `pvp=true`.
+//!
 //!   horizon-bots --server 127.0.0.1:25565 --bots 25 --behaviour mixed --seconds 360 --report bots.json
 //!
 //! It prints one JSON line a second (bots online, chunks received) and writes a summary with `--report`.
@@ -23,7 +29,7 @@ use horizon_protocol::{
    buf::{Reader, Writer},
    connection::{ConnWriter, Connection, Counters},
    crypto::offline_uuid,
-    ids,
+    entity_data, ids,
    item::Stack,
    packets::{
        Empty, configuration,
@@ -34,7 +40,7 @@ use horizon_protocol::{
 };
 use serde_json::json;
 use std::{
-    collections::HashSet,
+    collections::{BTreeMap, HashSet},
    sync::{
        Arc, LazyLock, Mutex, OnceLock,
        atomic::{AtomicBool, AtomicU64, Ordering},
@@ -48,7 +54,8 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m

  --server HOST:PORT     default 127.0.0.1:25565
  --bots N               default 10
-  --behaviour B          idle, walk, explore or mixed (60 % walk, 20 % explore, 20 % idle); default mixed.
+  --behaviour B          idle, walk, explore, fight or mixed (60 % walk, 20 % explore, 20 % idle); default mixed.
+                         fight needs gamemode=survival, force-gamemode=true and allow-flight=true.
                         stand: stays on the ground where the server puts it (/tp), for a survival test.
                         One abusive client, to test a server's limits (run it beside a normal crowd):
                         flood-move (--flood moves a tick, each 64 to 256 blocks away, ignoring chunks),
@@ -63,9 +70,12 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
                         into a writable book), flood-sign (four 384-character lines on the block
                         below), flood-recipe (recipe book placements)
  --flood N              packets a tick for the flood behaviours; default 100
-  --attack NAME          attack the player NAME twice a second, from wherever the bot is (a reach test);
+  --attack NAME          attack the player NAME twice a second, from wherever the bot is (a reach test),
+                         swinging after each attack as vanilla's client does. NAME,NAME...: each of them
+                         in the same tick (a multi-target kill aura, for the anticheat's tests);
                         the report gives each bot's last health
  --attack-after S       start attacking S seconds after joining; default 5
+  --no-swing             attack without swinging (a kill aura hiding its swing, for the anticheat's tests)
  --no-loaded            never say the level is loaded (ServerboundPlayerLoadedPacket): a vanilla server
                         ignores the player's moves and actions for its first 3 seconds
  --no-read              stop reading from the server once spawned (a client that lets the
@@ -75,6 +85,7 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
  --view-distance N      what the bots ask for; default 10
  --seed N               default 12345
  --explore-speed B      blocks a second an explore bot flies; default 22 (as fast as chunks come)
+  --pvp B                fight bots also attack each other (true or false); default true
  --name PREFIX          bot names: PREFIX0, PREFIX1...; default Bot
  --brand B              the client brand sent in configuration (minecraft:brand); default none
  --height H             blocks above spawn the bots fly at (walk, explore, idle); default 24
@@ -96,6 +107,7 @@ enum Behaviour {
    Stand,
    Walk,
    Explore,
+    Fight,
    FloodMove,
    FloodAcks,
    FloodPackets,
@@ -115,6 +127,7 @@ impl Behaviour {
            Self::Stand => "stand",
            Self::Walk => "walk",
            Self::Explore => "explore",
+            Self::Fight => "fight",
            Self::FloodMove => "flood-move",
            Self::FloodAcks => "flood-acks",
            Self::FloodPackets => "flood-packets",
@@ -139,9 +152,11 @@ struct Options {
    view_distance: i8,
    seed: u64,
    explore_speed: f64,
+    pvp: bool,
    /// The player to attack, and how long after joining to start.
    attack: Option<String>,
    attack_after: f64,
+    no_swing: bool,
    flood: usize,
    no_read: bool,
    no_loaded: bool,
@@ -172,8 +187,10 @@ fn options() -> Result<Options, String> {
        view_distance: 10,
        seed: 12345,
        explore_speed: 22.0,
+        pvp: true,
        attack: None,
        attack_after: 5.0,
+        no_swing: false,
        flood: 100,
        no_read: false,
        no_loaded: false,
@@ -197,6 +214,10 @@ fn options() -> Result<Options, String> {
            o.no_read = true;
            continue;
        }
+        if arg == "--no-swing" {
+            o.no_swing = true;
+            continue;
+        }
        if arg == "--no-loaded" {
            o.no_loaded = true;
            continue;
@@ -222,6 +243,7 @@ fn options() -> Result<Options, String> {
            "--explore-speed" => {
                o.explore_speed = value.parse().map_err(|_| number("blocks a second"))?;
            }
+            "--pvp" => o.pvp = value.parse().map_err(|_| number("true or false"))?,
            "--flood" => o.flood = value.parse().map_err(|_| number("packets a tick"))?,
            "--attack" => o.attack = Some(value),
            "--attack-after" => o.attack_after = value.parse().map_err(|_| number("seconds"))?,
@@ -285,10 +307,11 @@ fn options() -> Result<Options, String> {
            _ => return Err(format!("unknown option {arg}; --help lists them")),
        }
    }
-    const BEHAVIOURS: [&str; 15] = [
+    const BEHAVIOURS: [&str; 16] = [
        "idle",
        "walk",
        "explore",
+        "fight",
        "mixed",
        "stand",
        "flood-move",
@@ -304,7 +327,7 @@ fn options() -> Result<Options, String> {
    ];
    if !BEHAVIOURS.contains(&o.behaviour.as_str()) {
        return Err(format!(
-            "--behaviour {}: use idle, walk, explore, mixed or a flood behaviour (--help lists them)",
+            "--behaviour {}: use idle, walk, explore, fight, mixed or a flood behaviour (--help lists them)",
            o.behaviour
        ));
    }
@@ -325,6 +348,10 @@ struct Bot {
    pulled_back: AtomicU64,
    /// Ticks the bot couldn't move because it didn't hold its chunk yet.
    waited: AtomicU64,
+    /// Attack packets sent (fight bots and --attack).
+    attacks: AtomicU64,
+    /// The entities the server tells the bot about (fight bots only).
+    entities: Mutex<Entities>,
    /// The chunks the bot holds (ClientChunkCache).
    held: Mutex<HashSet<(i32, i32)>>,
    /// Where the server last put the bot (a teleport), to start from.
@@ -335,9 +362,8 @@ struct Bot {
    counters: OnceLock<Arc<Counters>>,
    /// The bot stopped reading (--no-read).
    deaf: AtomicBool,
-    /// `--attack`: the target's UUID and, once AddEntity showed it, its entity id.
-    target: Mutex<(Option<u128>, Option<i32>)>,
-    attacks: AtomicU64,
+    /// `--attack`: each target's UUID and, once AddEntity showed it, its entity id.
+    target: Mutex<Vec<(u128, Option<i32>)>>,
    /// The last SetHealth.
    health: Mutex<Option<f32>>,
 }
@@ -390,6 +416,142 @@ impl Random {
    }
 }

+/// Vanilla's bare-hand attack speed is 4 a second: a full-strength swing every 20 / 4 ticks.
+const ATTACK_COOLDOWN_TICKS: u32 = 5;
+/// How far, in blocks, a fight bot strikes (the survival entity interaction range is 3).
+const ATTACK_REACH: f64 = 2.5;
+/// A fight bot walks up to this horizontal distance, so it does not stand inside its target.
+const CLOSE_IN: f64 = 1.5;
+/// Walking speed in blocks a tick.
+const FIGHT_STEP: f64 = 0.215;
+/// `LivingEntity.DATA_HEALTH_ID`: only living entities carry it, and it is sent once it differs from 1.
+const HEALTH_DATA: u8 = 9;
+
+/// What a fight bot knows of one entity.
+#[derive(Clone, Debug, PartialEq)]
+struct Tracked {
+    uuid: u128,
+    pos: [f64; 3],
+    /// Set once the server sends the health of the entity, which only living entities have.
+    health: Option<f32>,
+}
+
+/// The entities around a bot, from AddEntity, the move packets, SetEntityData and RemoveEntities.
+/// Ordered by id, so ties between equally near targets always go to the same entity.
+#[derive(Default)]
+struct Entities(BTreeMap<i32, Tracked>);
+
+impl Entities {
+    fn update(&mut self, id: i32, body: &[u8]) {
+        let Ok(packet) = play::Clientbound::decode(id, body) else {
+            return;
+        };
+        match packet {
+            play::Clientbound::AddEntity(p) => {
+                self.0.insert(
+                    p.id,
+                    Tracked {
+                        uuid: p.uuid,
+                        pos: p.position,
+                        health: None,
+                    },
+                );
+            }
+            play::Clientbound::MoveEntityPos(play::MoveEntityPos(m))
+            | play::Clientbound::MoveEntityPosRot(play::MoveEntityPosRot(m)) => {
+                if let (Some(e), Some(delta)) = (self.0.get_mut(&m.id), &m.delta) {
+                    e.pos = delta.end(e.pos);
+                }
+            }
+            play::Clientbound::EntityPositionSync(p) => {
+                if let Some(e) = self.0.get_mut(&p.id) {
+                    e.pos = p.path.end();
+                }
+            }
+            play::Clientbound::SetEntityData(p) => {
+                if let Some(e) = self.0.get_mut(&p.id) {
+                    for (index, _, value) in &p.values {
+                        if *index == HEALTH_DATA
+                            && let entity_data::Value::Float(health) = value
+                        {
+                            e.health = Some(*health);
+                        }
+                    }
+                }
+            }
+            play::Clientbound::RemoveEntities(p) => {
+                for id in p.ids {
+                    self.0.remove(&id);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    /// The nearest living entity that is not dead; other bots only when `pvp`.
+    fn nearest(&self, from: [f64; 3], pvp: bool, bots: &HashSet<u128>) -> Option<(i32, [f64; 3])> {
+        let mut best: Option<(f64, i32, [f64; 3])> = None;
+        for (id, e) in &self.0 {
+            if !e.health.is_some_and(|h| h > 0.0) || (!pvp && bots.contains(&e.uuid)) {
+                continue;
+            }
+            let d = distance(from, e.pos);
+            if best.is_none_or(|(b, ..)| d < b) {
+                best = Some((d, *id, e.pos));
+            }
+        }
+        best.map(|(_, id, pos)| (id, pos))
+    }
+}
+
+fn distance(a: [f64; 3], b: [f64; 3]) -> f64 {
+    ((a[0] - b[0]).powi(2) + (a[1] - b[1]).powi(2) + (a[2] - b[2]).powi(2)).sqrt()
+}
+
+/// One tick of a fighting bot with a target: walk up to it, and strike once the cooldown is over.
+/// Returns the entity to attack. `since_attack` counts ticks since the last swing.
+fn fight_tick(pos: &mut [f64; 3], target: (i32, [f64; 3]), since_attack: &mut u32) -> Option<i32> {
+    *since_attack = since_attack.saturating_add(1);
+    let (id, at) = target;
+    let (dx, dz) = (at[0] - pos[0], at[2] - pos[2]);
+    let horizontal = dx.hypot(dz);
+    if horizontal > CLOSE_IN {
+        let step = FIGHT_STEP.min(horizontal - CLOSE_IN);
+        pos[0] += dx / horizontal * step;
+        pos[2] += dz / horizontal * step;
+    }
+    if *since_attack >= ATTACK_COOLDOWN_TICKS && distance(*pos, at) <= ATTACK_REACH {
+        *since_attack = 0;
+        return Some(id);
+    }
+    None
+}
+
+/// One tick of walking to random points around the spawn, at sprint speed (5.6 blocks a second).
+fn walk_step(
+    pos: &mut [f64; 3],
+    target: &mut [f64; 3],
+    spawn: [f64; 3],
+    cruise: f64,
+    random: &mut Random,
+) {
+    let (dx, dz) = (target[0] - pos[0], target[2] - pos[2]);
+    let distance = dx.hypot(dz);
+    if distance < 1.0 {
+        let angle = random.unit() * std::f64::consts::TAU;
+        let reach = 8.0 + random.unit() * 40.0;
+        *target = [
+            spawn[0] + angle.cos() * reach,
+            cruise,
+            spawn[2] + angle.sin() * reach,
+        ];
+    } else {
+        let step = 0.28_f64.min(distance);
+        pos[0] += dx / distance * step;
+        pos[2] += dz / distance * step;
+    }
+}
+
 /// One bot thread that panics poisons the locks it held; the others and the report go on.
 fn lock<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
    m.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
@@ -645,6 +807,7 @@ fn read(
    mut reader: horizon_protocol::connection::ConnReader,
    writer: Arc<Mutex<ConnWriter>>,
    bot: Arc<Bot>,
+    track: bool,
 ) {
    use ids::play::clientbound as cb;
    use ids::play::serverbound as sb;
@@ -701,11 +864,15 @@ fn read(
            }
            cb::ADD_ENTITY => {
                if let Ok(play::Clientbound::AddEntity(p)) = play::Clientbound::decode(id, &body) {
-                    let mut target = lock(&bot.target);
-                    if target.0 == Some(p.uuid) {
-                        target.1 = Some(p.id);
+                    for target in lock(&bot.target).iter_mut() {
+                        if target.0 == p.uuid {
+                            target.1 = Some(p.id);
+                        }
                    }
                }
+                if track {
+                    lock(&bot.entities).update(id, &body);
+                }
                Ok(())
            }
            cb::SET_HEALTH => {
@@ -758,6 +925,16 @@ fn read(
                }
                _ => Ok(()),
            },
+            cb::MOVE_ENTITY_POS
+            | cb::MOVE_ENTITY_POS_ROT
+            | cb::ENTITY_POSITION_SYNC
+            | cb::SET_ENTITY_DATA
+            | cb::REMOVE_ENTITIES
+                if track =>
+            {
+                lock(&bot.entities).update(id, &body);
+                Ok(())
+            }
            cb::DISCONNECT | cb::START_CONFIGURATION => {
                bot.online.store(false, Ordering::SeqCst);
                *lock(&bot.error) = Some(if id == cb::DISCONNECT {
@@ -787,6 +964,7 @@ fn run_bot(
    o: Arc<Options>,
    index: usize,
    behaviour: Behaviour,
+    bots: Arc<HashSet<u128>>,
    bot: Arc<Bot>,
    until: Arc<Mutex<Option<Instant>>>,
 ) {
@@ -802,11 +980,17 @@ fn run_bot(
    let (reader, writer) = connection.split();
    let _ = bot.counters.set(reader.counters.clone());
    let writer = Arc::new(Mutex::new(writer));
-    lock(&bot.target).0 = o.attack.as_deref().map(offline_uuid);
+    *lock(&bot.target) = o
+        .attack
+        .iter()
+        .flat_map(|names| names.split(','))
+        .map(|name| (offline_uuid(name), None))
+        .collect();
    bot.online.store(true, Ordering::SeqCst);
    {
        let (writer, bot) = (writer.clone(), bot.clone());
-        thread::spawn(move || read(reader, writer, bot));
+        let track = behaviour == Behaviour::Fight;
+        thread::spawn(move || read(reader, writer, bot, track));
    }
    use ids::play::serverbound as sb;
    // Wait for the spawn position.
@@ -857,7 +1041,13 @@ fn run_bot(
    let mut sequence = 0;
    let mut random = Random(o.seed ^ (index as u64).wrapping_mul(0x2545_F491_4F6C_DD1D));
    let mut pos = spawn;
-    let cruise = spawn[1] + o.height;
+    // Fight bots stay at their spawn height; the others climb to fly above the terrain.
+    let cruise = if behaviour == Behaviour::Fight {
+        spawn[1]
+    } else {
+        spawn[1] + o.height
+    };
+    let mut since_attack = ATTACK_COOLDOWN_TICKS;
    let heading = random.unit() * std::f64::consts::TAU;
    let mut target = pos;
    let mut next = Instant::now();
@@ -911,22 +1101,22 @@ fn run_bot(
        } else {
            match behaviour {
                Behaviour::Idle | Behaviour::Stand => {}
-                Behaviour::Walk => {
-                    let (dx, dz) = (target[0] - pos[0], target[2] - pos[2]);
-                    let distance = dx.hypot(dz);
-                    if distance < 1.0 {
-                        let angle = random.unit() * std::f64::consts::TAU;
-                        let reach = 8.0 + random.unit() * 40.0;
-                        target = [
-                            spawn[0] + angle.cos() * reach,
-                            cruise,
-                            spawn[2] + angle.sin() * reach,
-                        ];
+                Behaviour::Walk => walk_step(&mut pos, &mut target, spawn, cruise, &mut random),
+                Behaviour::Fight => {
+                    let near = lock(&bot.entities).nearest(pos, o.pvp, &bots);
+                    if let Some(near) = near {
+                        if let Some(victim) = fight_tick(&mut pos, near, &mut since_attack) {
+                            // The client sends the attack, then swings the arm.
+                            let sent = send(
+                                play::Serverbound::Attack(play::Attack { id: victim }).encode(),
+                            ) && send(raw(sb::PUNCH, |w| w.varint(0)));
+                            if sent {
+                                bot.attacks.fetch_add(1, Ordering::Relaxed);
+                            }
+                        }
                    } else {
-                        // Sprinting: 5.6 blocks a second.
-                        let step = 0.28_f64.min(distance);
-                        pos[0] += dx / distance * step;
-                        pos[2] += dz / distance * step;
+                        since_attack = since_attack.saturating_add(1);
+                        walk_step(&mut pos, &mut target, spawn, cruise, &mut random);
                    }
                }
                Behaviour::FloodMove
@@ -1012,13 +1202,16 @@ fn run_bot(
                send(body);
            }
        }
-        let target = lock(&bot.target).1;
-        if let Some(id) = target
-            && joined.elapsed().as_secs_f64() >= o.attack_after
-            && tick % 10 == 0
-        {
-            send(play::Serverbound::Attack(play::Attack { id }).encode());
-            bot.attacks.fetch_add(1, Ordering::Relaxed);
+        if joined.elapsed().as_secs_f64() >= o.attack_after && tick % 10 == 0 {
+            let targets: Vec<i32> = lock(&bot.target).iter().filter_map(|t| t.1).collect();
+            for id in targets {
+                send(play::Serverbound::Attack(play::Attack { id }).encode());
+                // Minecraft.startAttack swings right after the attack.
+                if !o.no_swing {
+                    send(play::Serverbound::Punch(Empty).encode());
+                }
+                bot.attacks.fetch_add(1, Ordering::Relaxed);
+            }
        }
        tick += 1;
        let ok = send(
@@ -1026,7 +1219,10 @@ fn run_bot(
                x: pos[0],
                y: pos[1],
                z: pos[2],
-                flags: u8::from(behaviour == Behaviour::Stand || o.ground),
+                // Fight bots stand on the ground; the others fly.
+                flags: u8::from(
+                    matches!(behaviour, Behaviour::Fight | Behaviour::Stand) || o.ground,
+                ),
            })
            .encode(),
        ) && send(raw(sb::CLIENT_TICK_END, |_| {}));
@@ -1053,6 +1249,7 @@ fn behaviour_of(mode: &str, index: usize) -> Behaviour {
        "stand" => Behaviour::Stand,
        "walk" => Behaviour::Walk,
        "explore" => Behaviour::Explore,
+        "fight" => Behaviour::Fight,
        "flood-move" => Behaviour::FloodMove,
        "flood-acks" => Behaviour::FloodAcks,
        "flood-packets" => Behaviour::FloodPackets,
@@ -1083,14 +1280,23 @@ fn main() {
    let start = Instant::now();
    let until: Arc<Mutex<Option<Instant>>> = Arc::new(Mutex::new(None));
    let bots: Vec<Arc<Bot>> = (0..o.bots).map(|_| Arc::new(Bot::default())).collect();
+    // The uuids of all bots, so that `--pvp false` leaves them alone.
+    let bot_uuids: Arc<HashSet<u128>> = Arc::new(
+        (0..o.bots)
+            .map(|i| offline_uuid(&format!("{}{i}", o.name)))
+            .collect(),
+    );
    let launcher = {
        let (o, bots, until) = (o.clone(), bots.clone(), until.clone());
+        let bot_uuids = bot_uuids.clone();
        thread::spawn(move || {
            let mut handles = Vec::new();
            for (i, bot) in bots.iter().enumerate() {
                let (o2, bot, until) = (o.clone(), bot.clone(), until.clone());
-                let behaviour = behaviour_of(&o.behaviour, i);
-                handles.push(thread::spawn(move || run_bot(o2, i, behaviour, bot, until)));
+                let (behaviour, uuids) = (behaviour_of(&o.behaviour, i), bot_uuids.clone());
+                handles.push(thread::spawn(move || {
+                    run_bot(o2, i, behaviour, uuids, bot, until);
+                }));
                thread::sleep(Duration::from_secs_f64(o.join_every));
            }
            handles
@@ -1127,6 +1333,7 @@ fn main() {
                "resent": total(|b| &b.resent),
                "pulled_back": total(|b| &b.pulled_back),
                "waited_ticks": total(|b| &b.waited),
+                "attacks": total(|b| &b.attacks),
            })
        );
        previous_chunks = chunks;
@@ -1146,6 +1353,7 @@ fn main() {
        "behaviour": o.behaviour,
        "seed": o.seed,
        "explore_speed": o.explore_speed,
+        "pvp": o.pvp,
        "view_distance": o.view_distance,
        "seconds": o.seconds,
        "joined": bots.iter().filter(|b| b.joined_after_ms.load(Ordering::SeqCst) > 0).count(),
@@ -1153,6 +1361,7 @@ fn main() {
        "resent": bots.iter().map(|b| b.resent.load(Ordering::Relaxed)).sum::<u64>(),
        "pulled_back": bots.iter().map(|b| b.pulled_back.load(Ordering::Relaxed)).sum::<u64>(),
        "waited_ticks": bots.iter().map(|b| b.waited.load(Ordering::Relaxed)).sum::<u64>(),
+        "attacks": bots.iter().map(|b| b.attacks.load(Ordering::Relaxed)).sum::<u64>(),
        "bytes_in": bots.iter().map(|b| b.bytes_in()).sum::<u64>(),
        "bytes_out": bots.iter().map(|b| b.bytes_out()).sum::<u64>(),
        "join_time": join_summary(
@@ -1205,6 +1414,123 @@ fn main() {
 #[cfg(test)]
 mod tests {
    use super::*;
+    use play::{
+        AddEntity, Clientbound, MoveEntity, MoveEntityPos, RemoveEntities, SetEntityData, VecDelta,
+    };
+
+    fn feed(entities: &mut Entities, packet: &Clientbound) {
+        let bytes = packet.encode();
+        let mut r = Reader::new(&bytes);
+        let id = r.varint().unwrap();
+        entities.update(id, &bytes[bytes.len() - r.remaining()..]);
+    }
+
+    fn add(id: i32, uuid: u128, pos: [f64; 3]) -> Clientbound {
+        Clientbound::AddEntity(AddEntity {
+            id,
+            uuid,
+            kind: 1,
+            position: pos,
+            velocity: [0.0; 3],
+            pitch: 0,
+            yaw: 0,
+            head_yaw: 0,
+            data: 0,
+        })
+    }
+
+    fn health(id: i32, health: f32) -> Clientbound {
+        Clientbound::SetEntityData(SetEntityData {
+            id,
+            values: vec![(HEALTH_DATA, 3, entity_data::Value::Float(health))],
+        })
+    }
+
+    #[test]
+    fn tracks_living_entities_only() {
+        let mut e = Entities::default();
+        feed(&mut e, &add(1, 10, [3.0, 64.0, 0.0]));
+        feed(&mut e, &add(2, 11, [5.0, 64.0, 0.0]));
+        feed(&mut e, &health(2, 20.0));
+        // Entity 1 never sent a health (an item, an arrow), so it is no target.
+        assert_eq!(
+            e.nearest([0.0, 64.0, 0.0], true, &HashSet::new()),
+            Some((2, [5.0, 64.0, 0.0]))
+        );
+        feed(&mut e, &health(2, 0.0));
+        assert_eq!(e.nearest([0.0, 64.0, 0.0], true, &HashSet::new()), None);
+        feed(&mut e, &health(2, 4.0));
+        feed(
+            &mut e,
+            &Clientbound::RemoveEntities(RemoveEntities { ids: vec![2] }),
+        );
+        assert_eq!(e.nearest([0.0, 64.0, 0.0], true, &HashSet::new()), None);
+    }
+
+    #[test]
+    fn moves_follow_the_deltas() {
+        let mut e = Entities::default();
+        feed(&mut e, &add(7, 1, [0.0, 64.0, 0.0]));
+        feed(&mut e, &health(7, 20.0));
+        feed(
+            &mut e,
+            &Clientbound::MoveEntityPos(MoveEntityPos(MoveEntity {
+                id: 7,
+                delta: Some(VecDelta::Linear([4096, 0, -8192])),
+                rotation: None,
+                on_ground: true,
+            })),
+        );
+        assert_eq!(e.0[&7].pos, [1.0, 64.0, -2.0]);
+    }
+
+    #[test]
+    fn pvp_false_spares_the_bots_and_ties_go_to_the_lowest_id() {
+        let mut e = Entities::default();
+        feed(&mut e, &add(9, 100, [2.0, 64.0, 0.0]));
+        feed(&mut e, &add(4, 101, [-2.0, 64.0, 0.0]));
+        feed(&mut e, &add(5, 102, [0.0, 64.0, 6.0]));
+        for id in [9, 4, 5] {
+            feed(&mut e, &health(id, 20.0));
+        }
+        let bots = HashSet::from([100, 101]);
+        let from = [0.0, 64.0, 0.0];
+        assert_eq!(e.nearest(from, true, &bots).map(|t| t.0), Some(4));
+        assert_eq!(e.nearest(from, false, &bots).map(|t| t.0), Some(5));
+    }
+
+    #[test]
+    fn attacks_at_the_vanilla_cooldown() {
+        let mut pos = [0.0, 64.0, 0.0];
+        let target = (3, [1.0, 64.0, 0.0]);
+        let mut since = ATTACK_COOLDOWN_TICKS;
+        let hits: Vec<u32> = (0..40)
+            .filter_map(|tick| fight_tick(&mut pos, target, &mut since).map(|_| tick))
+            .collect();
+        assert_eq!(hits[0], 0, "a bot in reach strikes at once");
+        assert!(
+            hits.windows(2)
+                .all(|w| w[1] - w[0] == ATTACK_COOLDOWN_TICKS)
+        );
+        assert_eq!(hits.len(), 8);
+    }
+
+    #[test]
+    fn walks_into_reach_before_striking() {
+        let mut pos = [0.0, 64.0, 0.0];
+        let target = (3, [10.0, 64.0, 0.0]);
+        let mut since = ATTACK_COOLDOWN_TICKS;
+        let mut first = None;
+        for tick in 0..100 {
+            if fight_tick(&mut pos, target, &mut since).is_some() {
+                first = Some(tick);
+                break;
+            }
+        }
+        assert!(first.is_some_and(|t| t > 30));
+        assert!((target.1[0] - pos[0]).abs() <= ATTACK_REACH);
+        assert!(pos[0] < 10.0 - CLOSE_IN + 1e-9);
+    }

    #[test]
    fn percentiles_use_nearest_rank() {
@@ -0,0 +1,15 @@
+[package]
+name = "horizon-chat-filter"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+rust-version = "1.88"
+description = "The dedicated server's chat filter: its [chat_filter] settings, the slur list's matcher and the mutes, with no game state (docs/chat-filter.md)"
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+toml = "1.1"
+
+[lints]
+workspace = true
@@ -0,0 +1,63 @@
+# Horizon's chat filter: the hate slurs a server refuses in chat, private messages, /say, /me, team
+# messages, signs, anvil names and book titles (docs/chat-filter.md). This is a moderation list: the
+# words are written here only so the filter can recognise them, because players spammed them on the
+# official server (2026-10-31). Add a word when players find a way around the list; keep insults that
+# aren't slurs out of it (moderators handle those).
+#
+# One entry a line, matched after normalising the text: lower case, accents and look-alike letters
+# (Cyrillic, Greek, full-width, small capitals...), leetspeak (1 i, 3 e, 4 a, 0 o, @ a, $ s, 9 g),
+# separators between letters (n.i.g, n_i_g) and repeated letters. A doubled letter in an entry must be
+# doubled in the text: "niger", the river and the country, isn't "nigger".
+#   word    matches inside a longer word too
+#   =word   only as a whole word ("spic", not "suspicious")
+#   ~word   also when it's spread over several words ("nig ger", "n i g g e r")
+#   !word   never a match: a word that contains an entry ("snigger"); !word* any word starting so
+
+~nigger
+~nigga
+nigguh
+niggah
+niqqa
+niqqer
+nlgger
+nlgga
+kneegrow
+=nig
+=nigs
+=niglet
+=niglets
+=nibba
+=nibbas
+=nibber
+=nibbers
+jigaboo
+porchmonkey
+=coon
+=coons
+~faggot
+=fag
+=fags
+=faggy
+=fagot
+=fagots
+=tranny
+=trannies
+=kike
+=kikes
+=chink
+=chinks
+=gook
+=gooks
+=spic
+=spics
+wetback
+=beaner
+=beaners
+raghead
+towelhead
+zipperhead
+=paki
+=pakis
+
+!snigger*
+!niggard*
@@ -0,0 +1,472 @@
+//! The dedicated server's chat filter (docs/chat-filter.md), without the game: `server.toml`'s
+//! `[chat_filter]`, the matcher for the slur list (`data/slurs.txt`, or the owner's `words_file`), and
+//! the escalation (a refused message, then a mute, then a temporary ban), with the mutes kept in a file
+//! so that they outlive a restart. The server's hub (`horizon_client::lan`) asks it before it relays a
+//! player's text and carries out what it decides.
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+
+mod normalise;
+
+pub use normalise::{Run, Text};
+
+/// The list built into the game, used when `words_file` is empty.
+pub const DEFAULT_WORDS: &str = include_str!("../data/slurs.txt");
+
+/// The mutes, beside server.properties.
+pub const MUTES_FILE: &str = "chat-filter-mutes.json";
+
+/// `server.toml`'s `[chat_filter]`: on by default.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Config {
+    pub enabled: bool,
+    /// The hit, counted within `window_minutes`, that mutes the player; 0: never.
+    pub mute_after: u32,
+    /// The hit that bans the player for `tempban_hours`; 0: never.
+    pub tempban_after: u32,
+    /// How long a hit counts towards the next ones (the time spent muted doesn't count).
+    pub window_minutes: u32,
+    pub mute_minutes: u32,
+    pub tempban_hours: u32,
+    /// The slur list, relative to the server's folder; empty: the list built into the game.
+    pub words_file: String,
+    /// Every refused text with the player and what followed, relative to the server's folder.
+    pub log: String,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            mute_after: 2,
+            tempban_after: 3,
+            window_minutes: 10,
+            mute_minutes: 10,
+            tempban_hours: 24,
+            words_file: String::new(),
+            log: "logs/chat-filter.log".into(),
+        }
+    }
+}
+
+impl Config {
+    /// The `[chat_filter]` section of a whole `server.toml`; the default without it.
+    pub fn from_server_toml(text: &str) -> Result<Self, String> {
+        #[derive(Deserialize)]
+        struct File {
+            #[serde(default)]
+            chat_filter: Config,
+        }
+        // Other sections are the supervisor's to check: only this one is read here.
+        let mut table: toml::Table = toml::from_str(text).map_err(|e| e.to_string())?;
+        let mut only = toml::Table::new();
+        if let Some(section) = table.remove("chat_filter") {
+            only.insert("chat_filter".into(), section);
+        }
+        let file: File = only
+            .try_into()
+            .map_err(|e: toml::de::Error| format!("[chat_filter]: {e}"))?;
+        file.chat_filter.check()?;
+        Ok(file.chat_filter)
+    }
+
+    pub fn check(&self) -> Result<(), String> {
+        if self.window_minutes == 0 {
+            return Err("chat_filter.window_minutes must be 1 or more".into());
+        }
+        Ok(())
+    }
+}
+
+/// How an entry of the list matches.
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Kind {
+    /// Inside a longer word too.
+    Embedded,
+    /// Only as a whole word.
+    Whole,
+    /// Inside a word, or spread over several words from the start of one.
+    Spread,
+}
+
+#[derive(Debug)]
+struct Entry {
+    runs: Vec<Run>,
+    kind: Kind,
+}
+
+/// The slur list, compiled: each entry's letters as runs, indexed by first letter.
+#[derive(Debug)]
+pub struct Filter {
+    entries: Vec<Entry>,
+    by_first: [Vec<u16>; 27],
+    /// Words never matched: exact (`false`) or as a prefix (`true`).
+    allowed: Vec<(Vec<Run>, bool)>,
+}
+
+impl Filter {
+    /// Compiles a list in `data/slurs.txt`'s format.
+    pub fn new(list: &str) -> Self {
+        let mut f = Filter {
+            entries: Vec::new(),
+            by_first: Default::default(),
+            allowed: Vec::new(),
+        };
+        for line in list.lines() {
+            let line = line.trim();
+            if line.is_empty() || line.starts_with('#') {
+                continue;
+            }
+            if let Some(word) = line.strip_prefix('!') {
+                let (word, prefix) = match word.strip_suffix('*') {
+                    Some(w) => (w, true),
+                    None => (word, false),
+                };
+                f.allowed.push((normalise::word(word), prefix));
+                continue;
+            }
+            let (kind, word) = match line.as_bytes()[0] {
+                b'=' => (Kind::Whole, &line[1..]),
+                b'~' => (Kind::Spread, &line[1..]),
+                _ => (Kind::Embedded, line),
+            };
+            let runs = normalise::word(word);
+            let Some(first) = runs.first() else {
+                continue;
+            };
+            f.by_first[usize::from(first.letter)].push(f.entries.len() as u16);
+            f.entries.push(Entry { runs, kind });
+        }
+        f
+    }
+
+    /// The built-in list.
+    pub fn default_list() -> Self {
+        Self::new(DEFAULT_WORDS)
+    }
+
+    pub fn len(&self) -> usize {
+        self.entries.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.entries.is_empty()
+    }
+
+    /// Whether `text` holds a slur of the list.
+    pub fn matches(&self, text: &str) -> bool {
+        let t = Text::new(text);
+        let runs = &t.runs;
+        for &(start, end) in t.words.iter().chain(&t.spaced) {
+            let word = &runs[start..end];
+            if self.is_allowed(word) {
+                continue;
+            }
+            for at in 0..word.len() {
+                for &e in &self.by_first[usize::from(word[at].letter)] {
+                    let e = &self.entries[usize::from(e)];
+                    let whole = e.kind == Kind::Whole;
+                    if (!whole || at == 0) && fits(&e.runs, &word[at..], whole) {
+                        return true;
+                    }
+                }
+            }
+        }
+        // Spread entries over the whole text, from the start of a word, across at least two.
+        for (w, &at) in t.joined_at.iter().enumerate() {
+            for &e in &self.by_first[usize::from(t.joined[at].letter)] {
+                let e = &self.entries[usize::from(e)];
+                if e.kind == Kind::Spread
+                    && fits(&e.runs, &t.joined[at..], false)
+                    && t.spans_words(w, e.runs.len())
+                {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+
+    fn is_allowed(&self, word: &[Run]) -> bool {
+        self.allowed.iter().any(|(a, prefix)| {
+            if *prefix {
+                // A prefix: its last run may be part of a longer one.
+                word.len() >= a.len() && fits(a, word, false)
+            } else {
+                fits(a, word, true)
+            }
+        })
+    }
+}
+
+/// Whether `entry`'s runs start `runs` (are all of it with `whole`): the same letters, each at least
+/// as many times as the entry has it.
+fn fits(entry: &[Run], runs: &[Run], whole: bool) -> bool {
+    if runs.len() < entry.len() || (whole && runs.len() != entry.len()) {
+        return false;
+    }
+    entry
+        .iter()
+        .zip(runs)
+        .all(|(e, r)| e.letter == r.letter && r.count >= e.count)
+}
+
+/// What a hit leads to.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Action {
+    /// The text is refused, nothing more.
+    Refused,
+    /// Refused, and the player can't chat until then (epoch milliseconds).
+    Muted { until: i64 },
+    /// Refused, and the player is banned until then.
+    Banned { until: i64 },
+}
+
+impl Action {
+    pub fn name(self) -> &'static str {
+        match self {
+            Action::Refused => "refused",
+            Action::Muted { .. } => "muted",
+            Action::Banned { .. } => "banned",
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Mute {
+    pub uuid: String,
+    pub name: String,
+    /// Epoch milliseconds.
+    pub until: i64,
+}
+
+#[derive(Default, Serialize, Deserialize)]
+struct MutesFile {
+    mutes: Vec<Mute>,
+}
+
+/// One player's hits: how many, and when the last one stops counting.
+#[derive(Clone, Copy, Debug)]
+struct Strikes {
+    count: u32,
+    counts_until: i64,
+}
+
+/// The filter, the players' hits and the mutes.
+pub struct Guard {
+    pub config: Config,
+    pub filter: Filter,
+    strikes: HashMap<u128, Strikes>,
+    mutes: HashMap<u128, Mute>,
+    /// Where the mutes are kept; `None` keeps them in memory only (tests).
+    file: Option<PathBuf>,
+}
+
+const MINUTE: i64 = 60_000;
+
+impl Guard {
+    pub fn new(config: Config, filter: Filter, file: Option<PathBuf>) -> Self {
+        let mut mutes = HashMap::new();
+        if let Some(text) = file.as_ref().and_then(|f| std::fs::read_to_string(f).ok())
+            && let Ok(saved) = serde_json::from_str::<MutesFile>(&text)
+        {
+            for m in saved.mutes {
+                if let Some(uuid) = parse_uuid(&m.uuid) {
+                    mutes.insert(uuid, m);
+                }
+            }
+        }
+        Self {
+            config,
+            filter,
+            strikes: HashMap::new(),
+            mutes,
+            file,
+        }
+    }
+
+    /// The server's guard: `words_file` or the built-in list, the mutes in `dir`. An unreadable
+    /// `words_file` falls back to the built-in list, with why.
+    pub fn load(config: Config, dir: &Path) -> (Self, Option<String>) {
+        let mut problem = None;
+        let filter = if config.words_file.is_empty() {
+            Filter::default_list()
+        } else {
+            match std::fs::read_to_string(dir.join(&config.words_file)) {
+                Ok(text) => Filter::new(&text),
+                Err(e) => {
+                    problem = Some(format!(
+                        "chat_filter.words_file {}: {e}; using the built-in list",
+                        config.words_file
+                    ));
+                    Filter::default_list()
+                }
+            }
+        };
+        (
+            Self::new(config, filter, Some(dir.join(MUTES_FILE))),
+            problem,
+        )
+    }
+
+    /// When the player's mute ends, if they are muted at `now`.
+    pub fn muted_until(&self, uuid: u128, now: i64) -> Option<i64> {
+        self.mutes
+            .get(&uuid)
+            .map(|m| m.until)
+            .filter(|&until| until > now)
+    }
+
+    /// A hit by the player at `now`: the hit's number in the window, and what it leads to.
+    pub fn strike(&mut self, uuid: u128, name: &str, now: i64) -> (u32, Action) {
+        let c = &self.config;
+        let window = i64::from(c.window_minutes) * MINUTE;
+        let s = self.strikes.entry(uuid).or_insert(Strikes {
+            count: 0,
+            counts_until: 0,
+        });
+        if now > s.counts_until {
+            s.count = 0;
+        }
+        s.count += 1;
+        s.counts_until = now + window;
+        let count = s.count;
+        let action = if c.tempban_after > 0 && count >= c.tempban_after {
+            self.strikes.remove(&uuid);
+            Action::Banned {
+                until: now + i64::from(c.tempban_hours) * 60 * MINUTE,
+            }
+        } else if c.mute_after > 0 && count >= c.mute_after {
+            let until = now + i64::from(c.mute_minutes) * MINUTE;
+            // The window starts again when the mute ends.
+            s.counts_until = until + window;
+            self.mutes.insert(
+                uuid,
+                Mute {
+                    uuid: uuid_string(uuid),
+                    name: name.to_owned(),
+                    until,
+                },
+            );
+            self.save();
+            Action::Muted { until }
+        } else {
+            Action::Refused
+        };
+        (count, action)
+    }
+
+    /// Lifts a player's mute (and forgets their hits), by name; the name as muted, if they were.
+    pub fn unmute(&mut self, name: &str) -> Option<String> {
+        let uuid = *self
+            .mutes
+            .iter()
+            .find(|(_, m)| m.name.eq_ignore_ascii_case(name))?
+            .0;
+        let mute = self.mutes.remove(&uuid)?;
+        self.strikes.remove(&uuid);
+        self.save();
+        Some(mute.name)
+    }
+
+    fn save(&mut self) {
+        let Some(file) = &self.file else {
+            return;
+        };
+        let now = now_millis();
+        self.mutes.retain(|_, m| m.until > now);
+        let mut mutes: Vec<Mute> = self.mutes.values().cloned().collect();
+        mutes.sort_by(|a, b| a.name.cmp(&b.name));
+        if let Ok(text) = serde_json::to_string_pretty(&MutesFile { mutes }) {
+            let tmp = file.with_extension("json.tmp");
+            if std::fs::write(&tmp, text).is_ok() {
+                let _ = std::fs::rename(&tmp, file);
+            }
+        }
+    }
+}
+
+/// One line of `logs/chat-filter.log`, without its newline.
+pub fn log_line(
+    now: i64,
+    name: &str,
+    uuid: u128,
+    place: &str,
+    count: u32,
+    action: Action,
+    text: &str,
+) -> String {
+    let text: String = text
+        .chars()
+        .map(|c| if c == '\n' { ' ' } else { c })
+        .collect();
+    format!(
+        "{} {name} {} {place} hit {count} {}: {text}",
+        utc(now),
+        uuid_string(uuid),
+        action.name()
+    )
+}
+
+/// Appends a line to the log at `path` (its folder made if needed).
+pub fn append_log(path: &Path, line: &str) -> std::io::Result<()> {
+    use std::io::Write;
+    if let Some(dir) = path.parent() {
+        std::fs::create_dir_all(dir)?;
+    }
+    let mut f = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(path)?;
+    writeln!(f, "{line}")
+}
+
+pub fn now_millis() -> i64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_or(0, |d| d.as_millis() as i64)
+}
+
+/// `YYYY-MM-DDTHH:MM:SSZ` for epoch milliseconds.
+pub fn utc(millis: i64) -> String {
+    let secs = millis.div_euclid(1000);
+    let (days, rest) = (secs.div_euclid(86_400), secs.rem_euclid(86_400));
+    // Howard Hinnant's civil_from_days.
+    let z = days + 719_468;
+    let era = z.div_euclid(146_097);
+    let doe = z.rem_euclid(146_097);
+    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let day = doy - (153 * mp + 2) / 5 + 1;
+    let month = if mp < 10 { mp + 3 } else { mp - 9 };
+    let year = yoe + era * 400 + i64::from(month <= 2);
+    format!(
+        "{year:04}-{month:02}-{day:02}T{:02}:{:02}:{:02}Z",
+        rest / 3600,
+        rest / 60 % 60,
+        rest % 60
+    )
+}
+
+fn uuid_string(u: u128) -> String {
+    let h = format!("{u:032x}");
+    format!(
+        "{}-{}-{}-{}-{}",
+        &h[..8],
+        &h[8..12],
+        &h[12..16],
+        &h[16..20],
+        &h[20..]
+    )
+}
+
+fn parse_uuid(s: &str) -> Option<u128> {
+    u128::from_str_radix(&s.replace('-', ""), 16).ok()
+}
+
+#[cfg(test)]
+mod tests;
@@ -0,0 +1,255 @@
+//! A text as the filter sees it: words of letters `a`..`z`, each letter with how many times it repeats.
+//! Case, accents, look-alike letters (Cyrillic, Greek, full-width, small capitals, styled mathematical
+//! letters, circled and squared letters), leetspeak and invisible characters are folded away;
+//! separators inside a word are dropped (`n.i.g` is `nig`), and whitespace ends a word.
+
+/// The letter code of anything that is a letter but none of `a`..`z`: it never matches.
+const OTHER: u8 = 26;
+
+/// One letter and how many times it repeats (`gg` is `g` twice).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Run {
+    /// 0..=25 for `a`..`z`, 26 for any other letter.
+    pub letter: u8,
+    pub count: u8,
+    /// Every one of its characters was punctuation read as a letter (`!` as `i`, `@` as `a`).
+    pub weak: bool,
+}
+
+/// A whole message, normalised.
+#[derive(Debug, Default)]
+pub struct Text {
+    pub runs: Vec<Run>,
+    /// Each word's runs, `runs[start..end]`.
+    pub words: Vec<(usize, usize)>,
+    /// More ranges of `runs` to match as words: letters spaced out (`n i g g a`), joined, and words
+    /// without the punctuation they end with (`fag!`).
+    pub spaced: Vec<(usize, usize)>,
+    /// Every word one after the other, a letter that ends one and starts the next merged.
+    pub joined: Vec<Run>,
+    /// Where each word starts in `joined`.
+    pub joined_at: Vec<usize>,
+    /// The last word each run of `joined` belongs to.
+    joined_last: Vec<usize>,
+}
+
+enum Fold {
+    Letter(u8, bool),
+    Separator,
+    Space,
+    Skip,
+}
+
+impl Text {
+    pub fn new(text: &str) -> Self {
+        let mut t = Text::default();
+        let mut start = 0;
+        for c in text.chars() {
+            match fold(c) {
+                Fold::Letter(letter, weak) => {
+                    let in_word = t.runs.len() > start;
+                    match t.runs.last_mut() {
+                        Some(last) if in_word && last.letter == letter => {
+                            last.count = last.count.saturating_add(1);
+                            last.weak &= weak;
+                        }
+                        _ => t.runs.push(Run {
+                            letter,
+                            count: 1,
+                            weak,
+                        }),
+                    }
+                }
+                Fold::Space => {
+                    t.end_word(start);
+                    start = t.runs.len();
+                }
+                Fold::Separator | Fold::Skip => {}
+            }
+        }
+        t.end_word(start);
+        t.add_spaced();
+        t.join();
+        t
+    }
+
+    fn end_word(&mut self, start: usize) {
+        if self.runs.len() > start {
+            self.words.push((start, self.runs.len()));
+        }
+    }
+
+    /// Spaced-out letters and words without their trailing punctuation, as extra words (their runs
+    /// copied after the real words').
+    fn add_spaced(&mut self) {
+        let words = self.words.len();
+        let mut w = 0;
+        while w < words {
+            let mut end = w;
+            while end < words && self.words[end].1 - self.words[end].0 == 1 {
+                end += 1;
+            }
+            if end - w >= 2 {
+                let first = self.runs.len();
+                for k in w..end {
+                    let run = self.runs[self.words[k].0];
+                    let in_word = self.runs.len() > first;
+                    match self.runs.last_mut() {
+                        Some(last) if in_word && last.letter == run.letter => {
+                            last.count = last.count.saturating_add(run.count);
+                        }
+                        _ => self.runs.push(run),
+                    }
+                }
+                self.spaced.push((first, self.runs.len()));
+                w = end;
+            } else {
+                w += 1;
+            }
+        }
+        for k in 0..words {
+            let (start, mut end) = self.words[k];
+            while end > start + 1 && self.runs[end - 1].weak {
+                end -= 1;
+            }
+            if end < self.words[k].1 {
+                self.spaced.push((start, end));
+            }
+        }
+    }
+
+    fn join(&mut self) {
+        for (w, &(start, end)) in self.words.iter().enumerate() {
+            let mut first = true;
+            for run in &self.runs[start..end] {
+                match self.joined.last_mut() {
+                    Some(last) if first && last.letter == run.letter => {
+                        last.count = last.count.saturating_add(run.count);
+                        self.joined_at.push(self.joined.len() - 1);
+                        *self.joined_last.last_mut().expect("beside joined") = w;
+                    }
+                    _ => {
+                        if first {
+                            self.joined_at.push(self.joined.len());
+                        }
+                        self.joined.push(*run);
+                        self.joined_last.push(w);
+                    }
+                }
+                first = false;
+            }
+        }
+    }
+
+    /// Whether `len` runs of `joined` from word `w`'s start reach into a later word.
+    pub fn spans_words(&self, w: usize, len: usize) -> bool {
+        self.joined_last
+            .get(self.joined_at[w] + len - 1)
+            .is_some_and(|&last| last > w)
+    }
+}
+
+/// An entry of the list, normalised the same way (one word, whitespace ignored).
+pub fn word(text: &str) -> Vec<Run> {
+    let t = Text::new(&text.replace(char::is_whitespace, ""));
+    t.words
+        .first()
+        .map_or_else(Vec::new, |&(s, e)| t.runs[s..e].to_vec())
+}
+
+fn letter(c: char) -> Fold {
+    Fold::Letter(c as u8 - b'a', false)
+}
+
+fn fold(c: char) -> Fold {
+    if c.is_ascii_alphabetic() {
+        return letter(c.to_ascii_lowercase());
+    }
+    if c.is_ascii() {
+        return match c {
+            '0' => letter('o'),
+            '1' => letter('i'),
+            '3' => letter('e'),
+            '4' => letter('a'),
+            '5' => letter('s'),
+            '6' | '9' => letter('g'),
+            '7' => letter('t'),
+            '8' => letter('b'),
+            '!' | '|' => Fold::Letter(b'i' - b'a', true),
+            '@' => Fold::Letter(0, true),
+            '$' => Fold::Letter(b's' - b'a', true),
+            c if c.is_ascii_whitespace() => Fold::Space,
+            _ => Fold::Separator,
+        };
+    }
+    let u = c as u32;
+    let from = |base: u32, span: u32| char::from(b'a' + ((u - base) % span) as u8);
+    let mapped = match u {
+        // Zero-width characters, soft hyphen, combining marks, variation selectors.
+        0xAD | 0x34F | 0x200B..=0x200F | 0x2060..=0x2064 | 0xFEFF | 0x180E => return Fold::Skip,
+        0x300..=0x36F
+        | 0x1AB0..=0x1AFF
+        | 0x1DC0..=0x1DFF
+        | 0x20D0..=0x20FF
+        | 0xFE00..=0xFE0F
+        | 0xFE20..=0xFE2F
+        | 0xE0100..=0xE01EF => return Fold::Skip,
+        // Full-width Latin and digits.
+        0xFF21..=0xFF3A => from(0xFF21, 26),
+        0xFF41..=0xFF5A => from(0xFF41, 26),
+        0xFF10..=0xFF19 => return fold(char::from(b'0' + (u - 0xFF10) as u8)),
+        // Mathematical alphanumerics: 52 letters a style, then digits.
+        0x1D400..=0x1D6A3 => from(0x1D400, 26),
+        0x1D7CE..=0x1D7FF => return fold(char::from(b'0' + ((u - 0x1D7CE) % 10) as u8)),
+        // Circled, parenthesised, squared and negative letters, regional indicators.
+        0x24B6..=0x24CF => from(0x24B6, 26),
+        0x24D0..=0x24E9 => from(0x24D0, 26),
+        0x249C..=0x24B5 => from(0x249C, 26),
+        0x1F130..=0x1F149 => from(0x1F130, 26),
+        0x1F150..=0x1F169 => from(0x1F150, 26),
+        0x1F170..=0x1F189 => from(0x1F170, 26),
+        0x1F1E6..=0x1F1FF => from(0x1F1E6, 26),
+        _ => {
+            if c.is_whitespace() {
+                return Fold::Space;
+            }
+            let lower = c.to_lowercase().next().unwrap_or(c);
+            match LOOK_ALIKES.iter().find(|(_, chars)| chars.contains(lower)) {
+                Some((base, _)) => *base,
+                None if c.is_alphabetic() => return Fold::Letter(OTHER, false),
+                None => return Fold::Separator,
+            }
+        }
+    };
+    letter(mapped)
+}
+
+/// Letters with accents and letters that look like a Latin one, by the letter they read as (lower case).
+const LOOK_ALIKES: &[(char, &str)] = &[
+    ('a', "àáâãäåāăąǎǟǡǻȁȃȧạảấầẩẫậắằẳẵặⱥɐаαᴀᵃª"),
+    ('b', "ƀɓḃḅḇвьъβʙᵇ"),
+    ('c', "çćĉċčƈḉȼсϲᴄᶜ"),
+    ('d', "ďđɗḋḍḏḑḓԁδᴅᵈ"),
+    ('e', "èéêëēĕėęěȅȇȩẹẻẽếềểễệḕḗḙḛḝɇеёєεᴇᵉ€"),
+    ('f', "ƒḟꜰᶠ"),
+    ('g', "ĝğġģǥǧǵɠḡɡɢᵍ"),
+    ('h', "ĥħȟḣḥḧḩḫẖнһʜʰ"),
+    ('i', "ìíîïĩīĭįıǐȉȋḭḯỉịіїιɪⁱ¡ӏ"),
+    ('j', "ĵǰјᴊʲ"),
+    ('k', "ķĸǩḱḳḵкκᴋᵏ"),
+    ('l', "ĺļľŀłḷḹḻḽʟˡ"),
+    ('m', "мᴍᵐ"),
+    ('n', "ñńņňŉŋǹṅṇṉṋиипηπɴⁿ"),
+    ('o', "òóôõöøōŏőơǒǫǭǿȍȏȫȭȯȱọỏốồổỗộớờởỡợоοσᴏᵒº"),
+    ('p', "ṕṗрρᴘᵖ"),
+    ('q', "ԛ"),
+    ('r', "ŕŗřȑȓṙṛṝṟгʀʳ"),
+    ('s', "śŝşšșṡṣṥṧṩѕꜱˢß"),
+    ('t', "ţťŧțṫṭṯṱẗтτᴛᵗ"),
+    ('u', "ùúûüũūŭůűųưǔǖǘǚǜȕȗụủứừửữựυᴜᵘ"),
+    ('v', "νᴠᵛ"),
+    ('w', "ŵẁẃẅẇẉẘԝωᴡʷ"),
+    ('x', "хχˣ"),
+    ('y', "ýÿŷȳẏẙỳỵỷỹуүγʏʸ"),
+    ('z', "źżžƶẑẓẕᴢᶻ"),
+];
@@ -0,0 +1,253 @@
+// The test texts spell the slurs the filter must refuse: that is what they test.
+use super::*;
+
+fn filter() -> Filter {
+    Filter::default_list()
+}
+
+#[test]
+fn the_list_compiles() {
+    let f = filter();
+    assert!(f.len() > 30, "{} entries", f.len());
+    assert_eq!(f.allowed.len(), 2);
+}
+
+#[test]
+fn normalising_catches_the_usual_disguises() {
+    let f = filter();
+    for text in [
+        "nigger",
+        "NIGGER",
+        "shut up nigga",
+        "Niggers",
+        "n1gg3r",
+        "ni99a",
+        "N!GGA",
+        "nigg@",
+        "n.i.g.g.e.r",
+        "n_i_g_g_a",
+        "n i g g e r",
+        "n i gg a",
+        "nig ger",
+        "nig  gaaa",
+        "niiiiggggggerrrrr",
+        "ñíggér",
+        "ｎｉｇｇｅｒ",
+        "Niggeг",         // Cyrillic ghe for r
+        "nіgger",         // Cyrillic i
+        "nigg\u{0435}r",  // Cyrillic e
+        "n\u{200B}igger", // a zero-width space
+        "n\u{0301}igger", // a combining accent
+        "𝐧𝐢𝐠𝐠𝐞𝐫",
+        "ⓝⓘⓖⓖⓐ",
+        "ɴɪɢɢᴀ",
+        "hi nig",
+        "f a g",
+        "fag!",
+        "you $pic",
+        "FAGGOTINO-CHAN",
+        "sandnigger",
+        "lol kike",
+    ] {
+        assert!(f.matches(text), "{text:?} should be refused");
+    }
+}
+
+#[test]
+fn ordinary_words_pass() {
+    let f = filter();
+    for text in [
+        "hello",
+        "Niger",
+        "I live in Niger",
+        "Nigeria and the Niger river",
+        "nigerian food",
+        "proud2benigerian",
+        "don't snigger",
+        "sniggering at that",
+        "a niggardly offer",
+        "knight",
+        "qKnights",
+        "its still night",
+        "anyone able to boot the latest nightly version?",
+        "i hate nighbours",
+        "can someune give mi night vision",
+        "suspicious stew",
+        "spicy food",
+        "a raccoon in a cocoon",
+        "Scunthorpe",
+        "bigger trigger digger",
+        "gg",
+        "gg ez",
+        "mini gg all",
+        "kniga",
+        "shenanigans",
+        "dignity and signing",
+        "Pakistan",
+        "chinking glasses",
+        "the trannys? no: transmission",
+        "1nicerOli",
+        "ask me evernig",
+        "冰淇淋",
+        "привет",
+        "",
+        "!!!",
+    ] {
+        assert!(!f.matches(text), "{text:?} should pass");
+    }
+}
+
+#[test]
+fn a_custom_list_has_the_same_syntax() {
+    let f = Filter::new("# comment\n=bad\n~worse\nmeh\n!mehish*\n");
+    assert!(f.matches("so bad"));
+    assert!(!f.matches("badly"));
+    assert!(f.matches("wor se"));
+    assert!(f.matches("xxmehxx"));
+    assert!(!f.matches("mehishness"));
+    assert!(!f.matches("me h"));
+}
+
+fn guard(config: Config) -> Guard {
+    Guard::new(config, filter(), None)
+}
+
+const NOW: i64 = 1_793_469_939_000;
+const MIN: i64 = 60_000;
+
+#[test]
+fn the_second_hit_mutes_and_the_third_bans() {
+    let mut g = guard(Config::default());
+    let id = 7;
+    assert_eq!(g.strike(id, "Ann", NOW), (1, Action::Refused));
+    assert_eq!(g.muted_until(id, NOW), None);
+    let until = NOW + 3 * MIN + 10 * MIN;
+    assert_eq!(
+        g.strike(id, "Ann", NOW + 3 * MIN),
+        (2, Action::Muted { until })
+    );
+    assert_eq!(g.muted_until(id, NOW + 4 * MIN), Some(until));
+    assert_eq!(g.muted_until(id, until), None);
+    // The time spent muted doesn't count: 8 minutes after the mute ended is still within the window.
+    assert_eq!(
+        g.strike(id, "Ann", until + 8 * MIN),
+        (
+            3,
+            Action::Banned {
+                until: until + 8 * MIN + 24 * 60 * MIN
+            }
+        )
+    );
+    // Then it starts again.
+    assert_eq!(g.strike(id, "Ann", until + 9 * MIN), (1, Action::Refused));
+}
+
+#[test]
+fn hits_far_apart_dont_add_up() {
+    let mut g = guard(Config::default());
+    assert_eq!(g.strike(1, "Bo", NOW), (1, Action::Refused));
+    assert_eq!(g.strike(1, "Bo", NOW + 11 * MIN), (1, Action::Refused));
+    // Players are counted apart.
+    assert_eq!(g.strike(2, "Cy", NOW + 12 * MIN), (1, Action::Refused));
+}
+
+#[test]
+fn thresholds_are_configurable() {
+    let mut g = guard(Config {
+        mute_after: 0,
+        tempban_after: 2,
+        tempban_hours: 1,
+        ..Config::default()
+    });
+    assert_eq!(g.strike(1, "Bo", NOW), (1, Action::Refused));
+    assert_eq!(
+        g.strike(1, "Bo", NOW + MIN),
+        (
+            2,
+            Action::Banned {
+                until: NOW + MIN + 60 * MIN
+            }
+        )
+    );
+    let mut off = guard(Config {
+        mute_after: 0,
+        tempban_after: 0,
+        ..Config::default()
+    });
+    for k in 1..5 {
+        assert_eq!(off.strike(1, "Bo", NOW + k), (k as u32, Action::Refused));
+    }
+}
+
+#[test]
+fn mutes_survive_a_restart_and_unmute_lifts_them() {
+    let dir = std::env::temp_dir().join(format!("chat-filter-test-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let now = now_millis();
+    let (mut g, problem) = Guard::load(Config::default(), &dir);
+    assert_eq!(problem, None);
+    g.strike(5, "Dee", now);
+    let (_, action) = g.strike(5, "Dee", now);
+    assert!(matches!(action, Action::Muted { .. }));
+    let (mut again, _) = Guard::load(Config::default(), &dir);
+    assert!(again.muted_until(5, now).is_some());
+    assert_eq!(again.unmute("dee").as_deref(), Some("Dee"));
+    assert_eq!(again.unmute("dee"), None);
+    assert_eq!(again.muted_until(5, now), None);
+    let (reloaded, _) = Guard::load(Config::default(), &dir);
+    assert_eq!(reloaded.muted_until(5, now), None);
+    std::fs::remove_dir_all(&dir).unwrap();
+}
+
+#[test]
+fn a_missing_words_file_falls_back_to_the_built_in_list() {
+    let config = Config {
+        words_file: "nope.txt".into(),
+        ..Config::default()
+    };
+    let (g, problem) = Guard::load(config, Path::new("/nonexistent-horizon"));
+    assert!(problem.unwrap().contains("nope.txt"));
+    assert!(g.filter.matches("nigger"));
+}
+
+#[test]
+fn the_section_reads_from_server_toml() {
+    let c = Config::from_server_toml("[server]\nport = 25565\n").unwrap();
+    assert_eq!(c, Config::default());
+    assert!(c.enabled);
+    let c = Config::from_server_toml(
+        "[chat_filter]\nenabled = true\nmute_after = 3\ntempban_after = 5\nwords_file = \"slurs.txt\"\n",
+    )
+    .unwrap();
+    assert_eq!((c.mute_after, c.tempban_after), (3, 5));
+    assert_eq!(c.words_file, "slurs.txt");
+    assert!(
+        !Config::from_server_toml("[chat_filter]\nenabled = false\n")
+            .unwrap()
+            .enabled
+    );
+    assert!(Config::from_server_toml("[chat_filter]\nmute = 2\n").is_err());
+    assert!(Config::from_server_toml("[chat_filter]\nwindow_minutes = 0\n").is_err());
+}
+
+#[test]
+fn log_lines_have_the_time_the_player_and_the_text() {
+    assert_eq!(utc(0), "1970-01-01T00:00:00Z");
+    assert_eq!(utc(951_782_400_000), "2000-02-29T00:00:00Z");
+    assert_eq!(
+        log_line(NOW, "Ann", 1, "chat", 2, Action::Muted { until: 0 }, "a\nb"),
+        "2026-10-31T18:05:39Z Ann 00000000-0000-0000-0000-000000000001 chat hit 2 muted: a b"
+    );
+}
+
+#[test]
+fn a_message_costs_little() {
+    // A long message through the whole list stays far below a tick (debug builds included).
+    let f = filter();
+    let text = "the quick brown fox jumps over the lazy dog ".repeat(6);
+    let start = std::time::Instant::now();
+    for _ in 0..1000 {
+        assert!(!f.matches(&text));
+    }
+    assert!(start.elapsed().as_millis() < 2000, "{:?}", start.elapsed());
+}
@@ -57,6 +57,9 @@ impl ResourceSource for Bundled {
            "assets/horizon/lang/en_us.json" => {
                include_str!("../../horizon-client/assets/horizon/lang/en_us.json")
            }
+            "assets/horizon/lang/zh_cn.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/zh_cn.json")
+            }
            "assets/horizon/lang/ru_ru.json" => {
                include_str!("../../horizon-client/assets/horizon/lang/ru_ru.json")
            }
@@ -66,6 +69,9 @@ impl ResourceSource for Bundled {
            "assets/horizon/lang/uk_ua.json" => {
                include_str!("../../horizon-client/assets/horizon/lang/uk_ua.json")
            }
+            "assets/horizon/lang/tr_tr.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/tr_tr.json")
+            }
            "assets/horizon/lang/es_es.json"
            | "assets/horizon/lang/es_ar.json"
            | "assets/horizon/lang/es_cl.json"
@@ -288,6 +294,16 @@ mod tests {
        }
        assert_eq!(en.get("horizon.pages.mods"), Some("Mods"));
        assert_eq!(ru.get("horizon.pages.mods"), Some("Моды"));
+        let zh = Language::load(&[&empty], "zh_cn");
+        assert_eq!(zh.get("horizon.options.controller"), Some("手柄"));
+        assert_eq!(zh.get("horizon.pages.mods"), Some("模组"));
+        assert_eq!(zh.get("Preset"), Some("预设"));
+        assert_eq!(zh.get("%s chunks"), Some("%s 个区块"));
+        // Not every bundle is complete: the en_us layer is in every map, so a
+        // missing key falls back to English (`horizon.mods.not_built` is not
+        // in ru_ru either).
+        assert_eq!(zh.get("LOD Distance"), Some("LOD 距离"));
+        assert_eq!(ru.get("horizon.mods.not_built"), Some(" (Not built)"));
        let pl = Language::load(&[&empty], "pl_pl");
        assert_eq!(pl.get("horizon.options.controller"), Some("Kontroler"));
        assert_eq!(pl.get("horizon.options.vibration"), Some("Wibracje"));
@@ -296,6 +312,8 @@ mod tests {
            uk.get("horizon.options.on_screen_keyboard"),
            Some("Екранна клавіатура")
        );
+        let tr = Language::load(&[&empty], "tr_tr");
+        assert_eq!(tr.get("horizon.options.controller"), Some("Kontrolcü"));
        let es = Language::load(&[&empty], "es_es");
        assert_eq!(es.get("horizon.options.controller"), Some("Mando"));
        let es_ve = Language::load(&[&empty], "es_ve");
@@ -118,6 +118,12 @@ pub fn effect(id: &str) -> Option<&'static EffectDef> {
        None => mod_effect(id),
    }
 }
+/// A content mod's effect id (`<ns>:<path>`), not vanilla's with or
+/// without `minecraft:`.
+#[inline]
+pub fn is_mod_effect(id: &str) -> bool {
+    !id.starts_with("minecraft:") && id.bytes().any(|b| b == b':')
+}
 /// Out of line, so vanilla's lookups (every frame, every tick) stay as they were.
 #[cold]
 #[inline(never)]
@@ -130,6 +136,28 @@ pub fn description_id(id: &str) -> String {
    let (namespace, path) = id.split_once(':').unwrap_or(("minecraft", id));
    format!("effect.{namespace}.{}", path.replace('/', "."))
 }
+/// The effect's sprite in the GUI atlas (`Hud.getMobEffectSprite`: the key
+/// with `mob_effect/` before its path): `mob_effect/<path>` for vanilla's,
+/// `<ns>:mob_effect/<path>` for a mod's.
+pub fn sprite(id: &str) -> String {
+    let mut out = String::new();
+    push_sprite(&mut out, id);
+    out
+}
+/// [`sprite`], appended to `out`.
+pub fn push_sprite(out: &mut String, id: &str) {
+    let path = match id.split_once(':') {
+        None => id,
+        Some(("minecraft", path)) => path,
+        Some((namespace, path)) => {
+            out.push_str(namespace);
+            out.push(':');
+            path
+        }
+    };
+    out.push_str("mob_effect/");
+    out.push_str(path);
+}
 /// Namespaced effect ids for mob effect storage; a mod's id already is.
 pub fn namespaced(id: &'static str) -> &'static str {
    static IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
@@ -272,10 +300,15 @@ pub fn potion_color(id: Option<&str>) -> u32 {
    let Some(def) = id.and_then(potion) else {
        return BASE_POTION_COLOR;
    };
+    effects_color(def.effects.iter().map(|(id, _, amp)| (*id, *amp)))
+}
+/// `PotionContents.getColorOptional` of some effects, `(id, amplifier)`, all visible: the mix of
+/// their colours weighted by amplifier + 1, else the base potion colour.
+pub fn effects_color<'a>(effects: impl Iterator<Item = (&'a str, i32)>) -> u32 {
    let (mut r, mut g, mut b, mut total) = (0u32, 0u32, 0u32, 0u32);
-    for (e, _, amp) in def.effects {
+    for (e, amp) in effects {
        let Some(e) = effect(e) else { continue };
-        let w = *amp as u32 + 1;
+        let w = amp as u32 + 1;
        r += w * (e.color >> 16 & 255);
        g += w * (e.color >> 8 & 255);
        b += w * (e.color & 255);
@@ -295,10 +328,28 @@ mod tests {
    use super::*;

    #[test]
-    fn description_ids_keep_the_namespace() {
+    fn description_ids_and_sprites_keep_the_namespace() {
        assert_eq!(description_id("speed"), "effect.minecraft.speed");
        assert_eq!(description_id("minecraft:speed"), "effect.minecraft.speed");
        assert_eq!(description_id("ruby:curse/dark"), "effect.ruby.curse.dark");
+        assert_eq!(sprite("speed"), "mob_effect/speed");
+        assert_eq!(sprite("minecraft:speed"), "mob_effect/speed");
+        assert_eq!(sprite("ruby:curse/dark"), "ruby:mob_effect/curse/dark");
+    }
+
+    /// `PotionContents.getColorOptional`: each visible effect's colour weighted by its
+    /// amplifier + 1, the channels averaged by integer division; none gives the base colour.
+    #[test]
+    fn effects_mix_their_colours_by_amplifier() {
+        let c = |id: &str| effect(id).unwrap().color;
+        assert_eq!(effects_color([("poison", 0)].into_iter()), c("poison"));
+        let (p, s) = (c("poison"), c("speed"));
+        let mix = |shift: u32| (((p >> shift & 255) + 3 * (s >> shift & 255)) / 4) << shift;
+        assert_eq!(
+            effects_color([("poison", 0), ("speed", 2)].into_iter()),
+            mix(16) | mix(8) | mix(0)
+        );
+        assert_eq!(effects_color(std::iter::empty()), BASE_POTION_COLOR);
    }

    /// The only test that registers: the registry is set once per process.
@@ -320,6 +371,8 @@ mod tests {
            (0xFF0000, Category::Neutral, false)
        );
        assert!(effect("glow").is_none() && effect("ruby:late").is_none());
+        assert!(is_mod_effect(glow.id) && !is_mod_effect("speed"));
+        assert!(!is_mod_effect(namespaced("speed")));
        assert_eq!(namespaced(glow.id), "ruby:glow");
        assert_eq!(effect("minecraft:speed").unwrap().id, "speed");
        let ids: Vec<_> = all_effects().map(|e| e.id).collect();
@@ -28,6 +28,12 @@ pub struct Registries {
    /// Game rule name -> integer-valued.
    pub game_rules: Vec<(String, bool)>,
    pub players: Vec<String>,
+    /// A dedicated server's lists, for the completions of `/op`, `/deop`, `/pardon`, `/pardon-ip` and
+    /// `/whitelist`: the operators' names, the banned names and addresses, the whitelisted names.
+    pub ops: Vec<String>,
+    pub banned_players: Vec<String>,
+    pub banned_ips: Vec<String>,
+    pub whitelisted: Vec<String>,
    /// `ClientSuggestionProvider.customCompletionSuggestions`: the extra chat
    /// completions the server sent (ClientboundCustomChatCompletionsPacket),
    /// each once.
@@ -81,6 +81,19 @@ impl InteractionInput {
    }
 }

+/// The sentence of `Minecraft.handleKeybinds` that follows a key which opened
+/// a screen: `Gui.setScreen` has already run `KeyMapping.releaseAll()`, so
+/// `key.use` reads up and the same call releases an active use
+/// (`player.isUsingItem() && !keyUse.isDown()` → `MultiPlayerGameMode.releaseUsingItem`).
+/// Only the screens opened from the keybinds do this (the inventory, chat and
+/// advancements); the pause menu, server containers, mount inventories and
+/// dialogs release on the first tick after closing instead, as vanilla does.
+pub fn release_on_screen_open(world: &mut impl InteractionWorld) {
+    if world.using_item() {
+        world.release_using();
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -10,5 +10,6 @@ pub mod interaction_input;
 pub mod key_names;
 pub mod keybinds;
 pub mod keymapping;
+pub mod modifiers;
 pub mod mouse;
 pub mod window;
@@ -0,0 +1,232 @@
+//! OS modifier reconciliation and modifiers synthesized by agent control.
+
+use crate::{
+    keybinds::{KeyBinds, key_code},
+    keymapping::{KeyAction, SNEAK, SPRINT, ToggleKeys},
+};
+use std::collections::HashSet;
+use winit::keyboard::{KeyCode, ModifiersState};
+
+const MODIFIERS: [(ModifiersState, [KeyCode; 2]); 4] = [
+    (
+        ModifiersState::SHIFT,
+        [KeyCode::ShiftLeft, KeyCode::ShiftRight],
+    ),
+    (
+        ModifiersState::CONTROL,
+        [KeyCode::ControlLeft, KeyCode::ControlRight],
+    ),
+    (ModifiersState::ALT, [KeyCode::AltLeft, KeyCode::AltRight]),
+    (
+        ModifiersState::SUPER,
+        [KeyCode::SuperLeft, KeyCode::SuperRight],
+    ),
+];
+
+/// A synthesized key updates the same modifier word as window events.
+/// Releasing one side must preserve the other side's hold.
+pub fn set_key(
+    modifiers: &mut ModifiersState,
+    physical: &mut HashSet<KeyCode>,
+    key: KeyCode,
+    down: bool,
+) {
+    let Some((bit, pair)) = MODIFIERS.iter().find(|(_, pair)| pair.contains(&key)) else {
+        return;
+    };
+    if down {
+        physical.insert(key);
+    } else {
+        physical.remove(&key);
+    }
+    modifiers.set(*bit, pair.iter().any(|key| physical.contains(key)));
+}
+
+/// A modifier held for one synthesized click (the pad's Y, an agent's
+/// shift-click): what [`restore`] puts back once the click is done.
+#[derive(Clone, Copy, Debug)]
+pub struct Held {
+    key: KeyCode,
+    was_down: bool,
+    bit: bool,
+}
+
+/// Holds `key` in both the physical keys and the modifier word, which is
+/// what screens read (`InputWithModifiers.hasShiftDown`).
+pub fn hold(modifiers: &mut ModifiersState, physical: &mut HashSet<KeyCode>, key: KeyCode) -> Held {
+    let bit = MODIFIERS
+        .iter()
+        .find(|(_, pair)| pair.contains(&key))
+        .is_some_and(|(bit, _)| modifiers.contains(*bit));
+    let held = Held {
+        key,
+        was_down: physical.contains(&key),
+        bit,
+    };
+    set_key(modifiers, physical, key, true);
+    held
+}
+
+/// Undoes [`hold`]: a key or bit that was already down stays down.
+pub fn restore(modifiers: &mut ModifiersState, physical: &mut HashSet<KeyCode>, held: Held) {
+    if !held.was_down {
+        physical.remove(&held.key);
+    }
+    if let Some((bit, _)) = MODIFIERS.iter().find(|(_, pair)| pair.contains(&held.key)) {
+        modifiers.set(*bit, held.bit);
+    }
+}
+
+/// Recover missing modifier releases without releasing a rebound key or a pad.
+/// ToggleKeyMapping itself preserves keyboard and controller toggles on release.
+pub fn reconcile(
+    modifiers: ModifiersState,
+    physical: &mut HashSet<KeyCode>,
+    bindings: &KeyBinds,
+    toggles: &mut ToggleKeys,
+    options: [bool; 2],
+    pad_held: [bool; 2],
+) {
+    for (bit, pair) in MODIFIERS {
+        if modifiers.contains(bit) {
+            continue;
+        }
+        for key in pair {
+            if !physical.remove(&key) {
+                continue;
+            }
+            for (slot, name) in [(SNEAK, "key.sneak"), (SPRINT, "key.sprint")] {
+                if key_code(bindings.get(name)) == Some(key) && !pad_held[slot] {
+                    toggles.key(slot, KeyAction::Release, false, options[slot]);
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn modifier_taps_release_both_bits() {
+        let mut modifiers = ModifiersState::empty();
+        let mut physical = HashSet::new();
+        for (bit, pair) in MODIFIERS {
+            for key in pair {
+                set_key(&mut modifiers, &mut physical, key, true);
+                assert!(modifiers.contains(bit));
+                set_key(&mut modifiers, &mut physical, key, false);
+                assert!(modifiers.is_empty());
+                assert!(physical.is_empty());
+            }
+        }
+    }
+
+    #[test]
+    fn releasing_one_side_keeps_the_other_modifier_held() {
+        let mut modifiers = ModifiersState::empty();
+        let mut physical = HashSet::new();
+        for (bit, [left, right]) in MODIFIERS {
+            set_key(&mut modifiers, &mut physical, left, true);
+            set_key(&mut modifiers, &mut physical, right, true);
+            set_key(&mut modifiers, &mut physical, left, false);
+            assert!(modifiers.contains(bit));
+            set_key(&mut modifiers, &mut physical, right, false);
+            assert!(modifiers.is_empty());
+        }
+    }
+
+    #[test]
+    fn a_held_click_restores_the_previous_state() {
+        let mut modifiers = ModifiersState::empty();
+        let mut physical = HashSet::new();
+        let held = hold(&mut modifiers, &mut physical, KeyCode::ShiftLeft);
+        assert!(modifiers.shift_key());
+        restore(&mut modifiers, &mut physical, held);
+        assert!(modifiers.is_empty());
+        assert!(physical.is_empty());
+
+        // Right Shift already held, or the OS word set with no physical key.
+        for start in [HashSet::from([KeyCode::ShiftRight]), HashSet::new()] {
+            let mut modifiers = ModifiersState::SHIFT;
+            let mut physical = start.clone();
+            let held = hold(&mut modifiers, &mut physical, KeyCode::ShiftLeft);
+            restore(&mut modifiers, &mut physical, held);
+            assert_eq!(modifiers, ModifiersState::SHIFT);
+            assert_eq!(physical, start);
+        }
+    }
+
+    #[test]
+    fn lost_releases_respect_rebindings_and_pad_holds() {
+        for slot in [SNEAK, SPRINT] {
+            for rebound in [false, true] {
+                for pad in [false, true] {
+                    for toggle in [false, true] {
+                        let mut bindings = KeyBinds::default();
+                        let (name, modifier) = if slot == SNEAK {
+                            ("key.sneak", KeyCode::ShiftLeft)
+                        } else {
+                            ("key.sprint", KeyCode::ControlLeft)
+                        };
+                        if rebound {
+                            bindings.set(name, "key.keyboard.c");
+                        }
+                        let mut physical = HashSet::from([modifier]);
+                        if rebound {
+                            physical.insert(KeyCode::KeyC);
+                        }
+                        let mut toggles = ToggleKeys::default();
+                        toggles.key(slot, KeyAction::Press, false, toggle);
+                        let mut options = [false; 2];
+                        options[slot] = toggle;
+                        let mut pad_held = [false; 2];
+                        pad_held[slot] = pad;
+                        reconcile(
+                            ModifiersState::ALT,
+                            &mut physical,
+                            &bindings,
+                            &mut toggles,
+                            options,
+                            pad_held,
+                        );
+                        assert_eq!(toggles.is_down(slot), rebound || pad || toggle);
+                        assert!(!physical.contains(&modifier));
+                        assert_eq!(physical.contains(&KeyCode::KeyC), rebound);
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn unrelated_modifier_change_does_not_release_an_action() {
+        let mut toggles = ToggleKeys::default();
+        toggles.key(SNEAK, KeyAction::Press, false, false);
+        reconcile(
+            ModifiersState::ALT,
+            &mut HashSet::new(),
+            &KeyBinds::default(),
+            &mut toggles,
+            [false; 2],
+            [false; 2],
+        );
+        assert!(toggles.is_down(SNEAK));
+    }
+
+    #[test]
+    fn lost_modifier_release_preserves_a_controller_toggle() {
+        let mut toggles = ToggleKeys::default();
+        toggles.pad_toggle(SNEAK, false);
+        reconcile(
+            ModifiersState::empty(),
+            &mut HashSet::from([KeyCode::ShiftLeft]),
+            &KeyBinds::default(),
+            &mut toggles,
+            [false; 2],
+            [false; 2],
+        );
+        assert!(toggles.is_down(SNEAK));
+    }
+}
@@ -473,6 +473,37 @@ pub fn monitor_video_modes(monitor: &winit::monitor::MonitorHandle) -> Vec<Video
        .collect()
 }

+/// The video modes of the window's monitor, listed once per monitor. Listing them takes tens of
+/// milliseconds on Windows, and settings apply at every step of a dragged slider: listing them
+/// each time made the slider stutter.
+#[derive(Debug)]
+pub struct VideoModeList<M = winit::monitor::MonitorHandle> {
+    listed: Option<M>,
+}
+
+impl<M> Default for VideoModeList<M> {
+    fn default() -> Self {
+        Self { listed: None }
+    }
+}
+
+impl<M: PartialEq> VideoModeList<M> {
+    /// The modes of `monitor` when it is not the monitor listed last, else `None` (the list
+    /// stands). No monitor lists none.
+    pub fn refresh(
+        &mut self,
+        monitor: Option<M>,
+        list: impl FnOnce(&M) -> Vec<VideoMode>,
+    ) -> Option<Vec<VideoMode>> {
+        if monitor.is_some() && monitor == self.listed {
+            return None;
+        }
+        let modes = monitor.as_ref().map(list).unwrap_or_default();
+        self.listed = monitor;
+        Some(modes)
+    }
+}
+
 /// `Monitor.currentMode`: the monitor's desktop mode; winit has no such query, so the mode of
 /// the monitor's own size with the highest refresh rate and depth.
 fn monitor_current_mode(
@@ -698,4 +729,28 @@ mod tests {
            Some(Immediate)
        );
    }
+
+    #[test]
+    fn video_modes_are_listed_again_only_for_another_monitor() {
+        let mode = |width| VideoMode {
+            width,
+            height: 1080,
+            red_bits: 8,
+            green_bits: 8,
+            blue_bits: 8,
+            refresh_rate: 60.0,
+        };
+        let mut list = VideoModeList::default();
+        let mut listings = 0;
+        let mut modes = |monitor: &i32| {
+            listings += 1;
+            vec![mode(*monitor)]
+        };
+        assert_eq!(list.refresh(Some(1), &mut modes), Some(vec![mode(1)]));
+        assert_eq!(list.refresh(Some(1), &mut modes), None);
+        assert_eq!(list.refresh(Some(2), &mut modes), Some(vec![mode(2)]));
+        assert_eq!(list.refresh(None, &mut modes), Some(vec![]));
+        assert_eq!(list.refresh(Some(2), &mut modes), Some(vec![mode(2)]));
+        assert_eq!(listings, 3);
+    }
 }
@@ -15,6 +15,8 @@ horizon-command = { path = "../horizon-command" }
 horizon-core = { path = "../horizon-core" }
 horizon-hdr = { path = "../horizon-hdr" }
 horizon-items = { path = "../horizon-items" }
+# The narrator option's status and whether the narrator is there (Options.narrator).
+horizon-narrator = { path = "../horizon-narrator" }
 horizon-protocol = { path = "../horizon-protocol" }
 horizon-shader-api = { path = "../horizon-shader-api" }
 horizon-shaders = { path = "../horizon-shaders" }
@@ -33,18 +35,20 @@ glam = "0.30"
 log = "0.4"
 miniz_oxide = "0.8"
 naga = { version = "30.0.1", features = ["wgsl-in", "glsl-in", "hlsl-out"] }
+half = "2"
 png = "0.18"
 pollster = "0.4"
 serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1.0.151", features = ["raw_value"] }
 sha1 = "0.10"
 sha2 = "0.10.9"
+smallvec = { version = "1", features = ["const_new"] }
 symphonia = { version = "0.5", default-features = false, features = ["ogg", "vorbis"] }
 unicode-bidi = "0.3.18"
 ureq = { version = "2", default-features = false, features = ["tls"] }
 wgpu = { version = "30.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "metal", "wgsl", "naga-ir"] }
 winit = "0.30.13"
-zip = { version = "2", default-features = false, features = ["deflate"] }
+zip = { version = "9.1.3", default-features = false, features = ["deflate"] }

 [target.'cfg(unix)'.dependencies]
 rustix = { version = "1", default-features = false, features = ["std", "time"] }
@@ -235,6 +235,9 @@ impl RenderAssets {
        for stage in 0..10 {
            sprites.insert(root, &format!("minecraft:block/destroy_stage_{stage}"))?;
        }
+        if draws {
+            crate::native_emissive::load(root, &mut sprites);
+        }
        sprites.save_disk_cache();
        if draws {
            sprites.finish();
@@ -39,6 +39,12 @@ struct Channel {
    looping: bool,
    at: [f32; 3],
    relative: bool,
+    /// Whose sounds these are: 0 the game's, another splitscreen player's (`Audio::share`).
+    owner: u8,
+    /// Its world (`Mixer::world_id`; 0 none).
+    world: u32,
+    /// The sound file it started and when, to tell another player's copy of it.
+    started: Option<(String, std::time::Instant)>,
 }
 #[derive(Default)]
 struct Mixer {
@@ -46,6 +52,15 @@ struct Mixer {
    listener: [f64; 3],
    listener_yaw: f32,
    listener_pitch: f32,
+    /// Splitscreen: the other players' cameras (position, yaw, pitch) by owner. A world sound is
+    /// heard from the nearest camera, and panned half as wide while several share the speakers.
+    listeners: HashMap<u8, ([f64; 3], f32, f32)>,
+    /// Each camera's world by owner, as ids: the callback compares and copies integers.
+    worlds: HashMap<u8, u32>,
+    /// World names by id - 1 (`world_id`).
+    world_names: Vec<String>,
+    /// The callback's cameras (position, basis, world), kept to be refilled without allocating.
+    cameras: Vec<([f64; 3], Basis, u32)>,
    limiter_peak: f32,
    /// The output device the stream was opened on (`Library.currentDeviceName`).
    #[cfg(feature = "audio")]
@@ -54,6 +69,21 @@ struct Mixer {
    #[cfg(feature = "audio")]
    device_lost: bool,
 }
+/// A camera's forward, up and right vectors.
+type Basis = ([f64; 3], [f64; 3], [f64; 3]);
+impl Mixer {
+    /// The id of world `name` (1 and up), given once per name.
+    fn world_id(&mut self, name: &str) -> u32 {
+        let i = match self.world_names.iter().position(|w| w == name) {
+            Some(i) => i,
+            None => {
+                self.world_names.push(name.to_owned());
+                self.world_names.len() - 1
+            }
+        };
+        i as u32 + 1
+    }
+}
 /// A sound the player could have heard (`SoundEventListener.onPlaySound`):
 /// what the subtitle overlay needs.
 #[derive(Clone, Debug, PartialEq)]
@@ -75,7 +105,34 @@ pub struct MixerBackend {
    decoder: Option<std::sync::mpsc::Sender<Decode>>,
    next: ChannelId,
    live: bool,
+    /// Whose channels these are (`Channel::owner`).
+    owner: u8,
+    world: u32,
+    /// How many other players share this output: alone, a sound never looks for its copy.
+    shares: Arc<std::sync::atomic::AtomicUsize>,
 }
+/// A splitscreen player's backend leaving: its camera and sounds go with it.
+impl Drop for MixerBackend {
+    fn drop(&mut self) {
+        if self.owner == 0 {
+            return;
+        }
+        self.shares
+            .fetch_sub(1, std::sync::atomic::Ordering::Relaxed);
+        if let Ok(mut m) = self.mixer.lock() {
+            m.listeners.remove(&self.owner);
+            m.worlds.remove(&self.owner);
+            let owner = self.owner;
+            m.channels.retain(|_, c| c.owner != owner);
+        }
+    }
+}
+/// Splitscreen: each shared backend's channel ids start at a block of their own, never handed out
+/// again, so a player in a seat used before never reuses an id a departed one's decoder may
+/// still attach to. The game's own backend counts from 0, as before.
+static SHARED_CHANNELS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+/// Two players' copies of one sound: started within this of each other.
+const SAME_SOUND: std::time::Duration = std::time::Duration::from_millis(150);
 /// Decoded samples and their rate (`None`: the file did not load).
 type Samples = Option<(Arc<Vec<f32>>, u32)>;
 /// Decoded static sounds (`SoundBufferLibrary`'s buffers), dropped least
@@ -176,6 +233,11 @@ pub struct Audio {
    /// `SoundEngine.lastSeenDevices`: the system default output last seen.
    #[cfg(feature = "audio")]
    default_seen: Option<String>,
+    /// The ALSA cards (Linux) or Core Audio devices (macOS) last seen: listing
+    /// the output devices probes every one, so it waits for these to change
+    /// (`card_fingerprint`).
+    #[cfg(feature = "audio")]
+    cards_seen: Option<String>,
    /// The other half of `lastSeenDevices`: every output device last seen.
    #[cfg(feature = "audio")]
    devices_seen: Vec<String>,
@@ -225,7 +287,59 @@ fn decode(path: &Path) -> Option<(Vec<f32>, u32)> {
    }
    Some((mono, rate))
 }
+/// A sound file without its variant number (`mob/creeper/say2.ogg` is `mob/creeper/say`): each
+/// player's game picks its own variant of the same event.
+// ponytail: variants named by a trailing number, as vanilla's are; the event name if a pack breaks it.
+fn variantless(key: &str) -> &str {
+    key.trim_end_matches(".ogg")
+        .trim_end_matches(|c: char| c.is_ascii_digit())
+}
 impl MixerBackend {
+    /// Splitscreen: another player's game started this same sound here just now (both clients
+    /// heard it); this copy stays stopped, the first is heard from the nearest camera.
+    ///
+    /// A copy is recognised only by its file (without the variant), world, place and time: the
+    /// games pick variants on their own and play many sounds client-side (steps, digging), so
+    /// nothing marks two copies of one event. Two different events alike in all four (two
+    /// players' steps on grass, side by side, within 150 ms) are heard once. That is accepted:
+    /// at that distance and timing they sound like one; a doubled sound is the louder fault.
+    fn duplicate(&self, channel: ChannelId, (namespace, path): (&str, &str)) -> bool {
+        // Alone: nobody else's copy, and no lock taken for it.
+        if self.shares.load(std::sync::atomic::Ordering::Relaxed) == 0 {
+            return false;
+        }
+        let Ok(mut m) = self.mixer.lock() else {
+            return false;
+        };
+        // Alone (no other player's camera), or a sound by the listener (a click, music): its own.
+        let Some(c) = m.channels.get(&channel).filter(|c| !c.relative) else {
+            return false;
+        };
+        if m.listeners.is_empty() {
+            return false;
+        }
+        let key = format!("{namespace}:{path}");
+        let key = variantless(&key);
+        let at = c.at;
+        let world = c.world;
+        let twin = m.channels.values().any(|o| {
+            o.owner != self.owner
+                && o.world == world
+                && !o.relative
+                && o.started
+                    .as_ref()
+                    .is_some_and(|(k, t)| k == key && t.elapsed() < SAME_SOUND)
+                && (0..3).map(|i| (o.at[i] - at[i]).powi(2)).sum::<f32>() < 4.0
+        });
+        if let Some(c) = m.channels.get_mut(&channel) {
+            if twin {
+                c.state = State::Stopped;
+            } else {
+                c.started = Some((key.to_owned(), std::time::Instant::now()));
+            }
+        }
+        twin
+    }
    fn with(&self, channel: ChannelId, f: impl FnOnce(&mut Channel)) {
        if let Ok(mut m) = self.mixer.lock()
            && let Some(c) = m.channels.get_mut(&channel)
@@ -250,6 +364,9 @@ impl Backend for MixerBackend {
                looping: false,
                at: [0.0; 3],
                relative: false,
+                owner: self.owner,
+                world: self.world,
+                started: None,
            },
        );
        Some(id)
@@ -287,6 +404,10 @@ impl Backend for MixerBackend {
        }
        let (namespace, path) = sound.path();
        let file = self.root.join("assets").join(namespace).join(&path);
+        // A looping sound follows its entity in one client's tracking only: each keeps its own.
+        if !looping && self.duplicate(channel, (namespace, &path)) {
+            return;
+        }
        if sound.stream {
            // A streamed sound loops by restarting its stream.
            let mixer = self.mixer.clone();
@@ -395,28 +516,50 @@ fn distance_gain(linear: Option<f32>, distance: f32) -> f32 {
 #[cfg_attr(not(feature = "audio"), allow(dead_code))]
 fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
    data.fill(0.0);
-    let listener = mixer.listener;
    // The camera's forward and up vectors (`Camera.forwardVector`/`upVector`)
    // and OpenAL's right = forward x up.
-    let (yaw, pitch) = (
-        f64::from(mixer.listener_yaw.to_radians()),
-        f64::from(mixer.listener_pitch.to_radians()),
+    let basis = |yaw: f32, pitch: f32| {
+        let (yaw, pitch) = (f64::from(yaw.to_radians()), f64::from(pitch.to_radians()));
+        let forward = [
+            -yaw.sin() * pitch.cos(),
+            -pitch.sin(),
+            yaw.cos() * pitch.cos(),
+        ];
+        let up = [
+            -yaw.sin() * pitch.sin(),
+            pitch.cos(),
+            yaw.cos() * pitch.sin(),
+        ];
+        let right = [
+            forward[1] * up[2] - forward[2] * up[1],
+            forward[2] * up[0] - forward[0] * up[2],
+            forward[0] * up[1] - forward[1] * up[0],
+        ];
+        (forward, up, right)
+    };
+    // Every camera hearing (splitscreen: the other players' too), in the mixer's own buffer.
+    let mut cameras = std::mem::take(&mut mixer.cameras);
+    cameras.clear();
+    cameras.extend(
+        std::iter::once((
+            0,
+            (mixer.listener, mixer.listener_yaw, mixer.listener_pitch),
+        ))
+        .chain(
+            mixer
+                .listeners
+                .iter()
+                .map(|(&owner, &camera)| (owner, camera)),
+        )
+        .map(|(owner, (at, yaw, pitch))| {
+            (
+                at,
+                basis(yaw, pitch),
+                mixer.worlds.get(&owner).copied().unwrap_or_default(),
+            )
+        }),
    );
-    let forward = [
-        -yaw.sin() * pitch.cos(),
-        -pitch.sin(),
-        yaw.cos() * pitch.cos(),
-    ];
-    let up = [
-        -yaw.sin() * pitch.sin(),
-        pitch.cos(),
-        yaw.cos() * pitch.sin(),
-    ];
-    let right = [
-        forward[1] * up[2] - forward[2] * up[1],
-        forward[2] * up[0] - forward[0] * up[2],
-        forward[0] * up[1] - forward[1] * up[0],
-    ];
+    let shared = cameras.len() > 1;
    let dot = |a: [f64; 3], b: [f64; 3]| (a[0] * b[0] + a[1] * b[1] + a[2] * b[2]) as f32;
    // Gains and pans per source for this buffer.
    let mut voices: Vec<(ChannelId, [f32; 3], f64)> = Vec::new();
@@ -427,27 +570,48 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
        if c.state != State::Playing {
            continue;
        }
-        let d = if c.relative {
-            [f64::from(c.at[0]), f64::from(c.at[1]), f64::from(c.at[2])]
-        } else {
+        let at = [f64::from(c.at[0]), f64::from(c.at[1]), f64::from(c.at[2])];
+        let away = |listener: [f64; 3]| {
            [
-                f64::from(c.at[0]) - listener[0],
-                f64::from(c.at[1]) - listener[1],
-                f64::from(c.at[2]) - listener[2],
+                at[0] - listener[0],
+                at[1] - listener[1],
+                at[2] - listener[2],
            ]
        };
+        let length = |d: [f64; 3]| d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
+        // The nearest camera hears it (one camera but in splitscreen).
+        let camera = cameras
+            .iter()
+            .filter(|camera| c.relative || camera.2 == c.world)
+            .min_by(|a, b| length(away(a.0)).total_cmp(&length(away(b.0))))
+            .map(|camera| (camera.0, camera.1));
+        // Unheard sources still advance: returning to a world must not resume stale sounds.
+        let (listener, (forward, up, right)) = camera.unwrap_or(([0.0; 3], basis(0.0, 0.0)));
+        let d = if c.relative { at } else { away(listener) };
        let distance = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt() as f32;
-        let gain = c.gain.clamp(0.0, 1.0) * distance_gain(c.linear, distance);
+        let gain = if camera.is_some() {
+            c.gain.clamp(0.0, 1.0) * distance_gain(c.linear, distance)
+        } else {
+            0.0
+        };
        // Relative sources are already in OpenAL's listener space (-Z ahead).
-        let [left, right] = if c.relative {
+        let [mut left, mut right] = if c.relative {
            stereo_gains(d[0] as f32, d[1] as f32, -d[2] as f32)
        } else {
            stereo_gains(dot(d, right), dot(d, up), dot(d, forward))
+        };
+        if shared {
+            // Several players on the speakers: half the stereo width, as left and right are
+            // nobody's in particular.
+            let middle = (left + right) / 2.0;
+            left = middle + (left - middle) / 2.0;
+            right = middle + (right - middle) / 2.0;
        }
-        .map(|pan| gain * pan);
+        let [left, right] = [left, right].map(|pan| gain * pan);
        let step = f64::from(*source_rate) / f64::from(rate) * f64::from(c.pitch.max(0.0));
        voices.push((*id, [left, right, gain], step));
    }
+    mixer.cameras = cameras;
    for (id, [left, right, gain], step) in voices {
        let Some(c) = mixer.channels.get_mut(&id) else {
            continue;
@@ -538,6 +702,36 @@ fn open_device(
    }
    Ok((stream, config))
 }
+/// Try one output device for `open`: skip it when it was already tried, log it
+/// when it opens, and keep its error when it does not.
+#[cfg(feature = "audio")]
+fn try_open_device(
+    device: &cpal::Device,
+    mixer: Arc<Mutex<Mixer>>,
+    tried: &mut Vec<String>,
+    errors: &mut Vec<String>,
+) -> Option<cpal::Stream> {
+    let name = device.name().unwrap_or_else(|_| "unnamed device".into());
+    if tried.contains(&name) {
+        return None;
+    }
+    tried.push(name.clone());
+    match open_device(device, mixer) {
+        Ok((stream, config)) => {
+            log::info!(
+                "Horizon: audio output {name} ({} Hz, {} channels, {})",
+                config.sample_rate().0,
+                config.channels(),
+                config.sample_format()
+            );
+            Some(stream)
+        }
+        Err(e) => {
+            errors.push(format!("{name}: {e}"));
+            None
+        }
+    }
+}
 /// The name of the system's default output device.
 #[cfg(feature = "audio")]
 fn default_output_name() -> Option<String> {
@@ -545,6 +739,42 @@ fn default_output_name() -> Option<String> {
        .default_output_device()
        .and_then(|d| d.name().ok())
 }
+/// A cheap fingerprint of what `output_devices` can list. On Linux, the ALSA
+/// cards: the rest are `cpal`'s fixed names. On macOS, every Core Audio
+/// device's name, inputs included: telling which of them play opens each one
+/// (about 90 ms a second with twenty devices), naming them takes 2 or 3 ms.
+/// `None` elsewhere, where the list is always looked at.
+#[cfg(feature = "audio")]
+fn card_fingerprint() -> Option<String> {
+    #[cfg(target_os = "linux")]
+    {
+        std::fs::read_to_string("/proc/asound/cards").ok()
+    }
+    #[cfg(target_os = "macos")]
+    {
+        let devices = cpal::default_host().devices().ok()?;
+        Some(
+            devices
+                .filter_map(|d| d.name().ok())
+                .collect::<Vec<_>>()
+                .join("\n"),
+        )
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
+    {
+        None
+    }
+}
+/// Whether the output device list should be looked at again: only the ALSA
+/// cards can add or remove an entry, and `None` means there is no fingerprint,
+/// so the list has to be checked as before.
+#[cfg(any(feature = "audio", test))]
+fn cards_changed(seen: Option<&str>, cards: Option<&str>) -> bool {
+    match (seen, cards) {
+        (Some(seen), Some(cards)) => seen != cards,
+        _ => true,
+    }
+}
 #[cfg(feature = "audio")]
 fn build_stream<T: cpal::SizedSample + cpal::FromSample<f32>>(
    device: &cpal::Device,
@@ -649,6 +879,17 @@ impl Audio {
        };
        let mut engine = SoundEngine::new(registry);
        engine.loaded = live;
+        #[cfg(feature = "audio")]
+        let cards = if live { card_fingerprint() } else { None };
+        // Where the cards gate the list (Linux, macOS), it starts empty: opening the
+        // output does not need it, and listing it probes every device; the first
+        // change fills it. Elsewhere it starts with every device listed, as before.
+        #[cfg(feature = "audio")]
+        let devices = if live && cards.is_none() {
+            output_devices()
+        } else {
+            Vec::new()
+        };
        Self {
            _stream: stream,
            device_name: target_device.to_owned(),
@@ -660,6 +901,9 @@ impl Audio {
                decoder: None,
                next: 0,
                live,
+                owner: 0,
+                world: 0,
+                shares: Arc::default(),
            },
            record_heard: false,
            listener: [0.0; 3],
@@ -674,7 +918,9 @@ impl Audio {
            #[cfg(feature = "audio")]
            default_seen: if live { default_output_name() } else { None },
            #[cfg(feature = "audio")]
-            devices_seen: if live { output_devices() } else { Vec::new() },
+            cards_seen: cards,
+            #[cfg(feature = "audio")]
+            devices_seen: devices,
            #[cfg(feature = "audio")]
            device_ticks: 0,
        }
@@ -741,29 +987,20 @@ impl Audio {
        }
        let host = cpal::default_host();
        let mut errors = Vec::new();
-        // The default device first, then any other output a host lists:
-        // a default that cannot open (busy, or a stale ALSA default) should
-        // not leave the game silent when another device works.
-        let default = host.default_output_device();
-        let others = host.output_devices().into_iter().flatten();
+        // The default device first: it is what plays, and listing the others
+        // probes every PCM, which is slow and prints ALSA's errors for the
+        // plugins this system lacks.
        let mut tried = Vec::new();
-        for device in default.into_iter().chain(others) {
-            let name = device.name().unwrap_or_else(|_| "unnamed device".into());
-            if tried.contains(&name) {
-                continue;
-            }
-            tried.push(name.clone());
-            match open_device(&device, mixer.clone()) {
-                Ok((stream, config)) => {
-                    log::info!(
-                        "Horizon: audio output {name} ({} Hz, {} channels, {})",
-                        config.sample_rate().0,
-                        config.channels(),
-                        config.sample_format()
-                    );
-                    return Ok(stream);
-                }
-                Err(e) => errors.push(format!("{name}: {e}")),
+        if let Some(device) = host.default_output_device()
+            && let Some(stream) = try_open_device(&device, mixer.clone(), &mut tried, &mut errors)
+        {
+            return Ok(stream);
+        }
+        // A default that cannot open (busy, or a stale ALSA default) should not
+        // leave the game silent when another device works.
+        for device in host.output_devices().into_iter().flatten() {
+            if let Some(stream) = try_open_device(&device, mixer.clone(), &mut tried, &mut errors) {
+                return Ok(stream);
            }
        }
        if errors.is_empty() {
@@ -777,15 +1014,75 @@ impl Audio {
            backend: &mut self.backend,
        }
    }
+    /// World identity for this player's sources and camera. Existing channels keep their world.
+    pub fn set_world(&mut self, world: &str) {
+        if let Ok(mut mixer) = self.backend.mixer.lock() {
+            let id = mixer.world_id(world);
+            self.backend.world = id;
+            mixer.worlds.insert(self.backend.owner, id);
+        }
+    }
+
    /// `SoundManager.updateSource`: the camera position and rotation
    /// (`Listener.setTransform` takes its forward and up vectors).
    pub fn set_listener(&mut self, position: [f64; 3], yaw: f32, pitch: f32) {
        self.listener = position;
        self.listener_yaw = yaw;
        if let Ok(mut m) = self.backend.mixer.lock() {
-            m.listener = position;
-            m.listener_yaw = yaw;
-            m.listener_pitch = pitch;
+            if self.backend.owner == 0 {
+                m.listener = position;
+                m.listener_yaw = yaw;
+                m.listener_pitch = pitch;
+            } else {
+                m.listeners
+                    .insert(self.backend.owner, (position, yaw, pitch));
+            }
+        }
+    }
+    /// Splitscreen: another player's sounds on this output, heard from its camera too
+    /// (`owner`: 1 to 255, its own). Dropped, its camera and sounds go.
+    pub fn share(&self, owner: u8) -> Self {
+        assert_ne!(owner, 0, "shared audio owners must be nonzero");
+        self.backend
+            .shares
+            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        let mut engine = SoundEngine::new(self.engine.registry.clone());
+        engine.loaded = self.backend.live;
+        Self {
+            _stream: None,
+            device_name: self.device_name.clone(),
+            engine,
+            backend: MixerBackend {
+                mixer: self.backend.mixer.clone(),
+                root: self.backend.root.clone(),
+                cache: self.backend.cache.clone(),
+                decoder: None,
+                next: (SHARED_CHANNELS.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1)
+                    << 40,
+                live: self.backend.live,
+                owner,
+                world: self.backend.world,
+                shares: self.backend.shares.clone(),
+            },
+            record_heard: false,
+            listener: [0.0; 3],
+            listener_yaw: 0.0,
+            master: self.master,
+            random: LegacyRandom::new(crate::sound_engine::unique_seed()),
+            source_override: None,
+            capture: None,
+            heard: Default::default(),
+            stopped: Default::default(),
+            preview: Default::default(),
+            // The device belongs to the first player's output, which looks after it.
+            #[cfg(feature = "audio")]
+            default_seen: self.default_seen.clone(),
+            #[cfg(feature = "audio")]
+            cards_seen: self.cards_seen.clone(),
+            #[cfg(feature = "audio")]
+            devices_seen: self.devices_seen.clone(),
+            #[cfg(feature = "audio")]
+            device_ticks: 0,
        }
    }
    /// Sync the volume options, refreshing the categories that changed
@@ -810,6 +1107,11 @@ impl Audio {
    /// at once a second.
    #[cfg(feature = "audio")]
    fn should_change_device(&mut self) -> bool {
+        // A splitscreen share plays through the first player's output: it leaves the device,
+        // and the mixer's lost flag, to that output.
+        if self.backend.owner != 0 {
+            return false;
+        }
        let (current, lost) = match self.backend.mixer.lock() {
            Ok(mut m) => (m.device_name.clone(), std::mem::take(&mut m.device_lost)),
            Err(_) => return false,
@@ -817,6 +1119,7 @@ impl Audio {
        if lost {
            log::info!("Horizon: audio device was lost");
            self.default_seen = default_output_name();
+            self.cards_seen = card_fingerprint();
            self.devices_seen = output_devices();
            return true;
        }
@@ -826,6 +1129,17 @@ impl Audio {
        }
        self.device_ticks = 0;
        let default = default_output_name();
+        let cards = card_fingerprint();
+        // Listing the devices probes every one (on Linux every built-in PCM,
+        // printing ALSA's errors for the plugins this system lacks; on macOS
+        // every Core Audio device, about 90 ms with twenty of them); only the
+        // fingerprint's devices can change the list, and it is cheap.
+        if default == self.default_seen
+            && !cards_changed(self.cards_seen.as_deref(), cards.as_deref())
+        {
+            return false;
+        }
+        self.cards_seen = cards;
        let devices = output_devices();
        // Only a change in the device lists is looked at, as in vanilla: a
        // preferred device that is listed but cannot open is not retried.
@@ -1022,6 +1336,13 @@ impl Audio {
        self.stop_instance(id);
        self.release(id);
    }
+    /// `SoundBufferLibrary.enumerate`: the decoded buffers kept and their bytes.
+    pub fn cache_stats(&self) -> (usize, usize) {
+        self.backend
+            .cache
+            .lock()
+            .map_or((0, 0), |c| (c.entries.len(), c.bytes))
+    }
    /// Every sound event id (for command completion).
    /// The engine's table sizes and the mixer's channels (`status`).
    pub fn census(&self) -> serde_json::Value {
@@ -1140,6 +1461,9 @@ mod tests {
            looping,
            at,
            relative: false,
+            owner: 0,
+            world: 0,
+            started: None,
        }
    }

@@ -1297,6 +1621,185 @@ mod tests {
        assert!(close(gains(0.0, 90.0, [0.0, 0.0, 1.0]), [0.5, 0.5]));
    }

+    #[test]
+    fn splitscreen_sounds_are_heard_from_the_nearest_camera() {
+        // P1 far away, a second player beside the source: heard at full gain, centred.
+        let mut m = Mixer {
+            listener: [100.0, 0.0, 0.0],
+            ..Mixer::default()
+        };
+        m.listeners.insert(1, ([0.0, 0.0, 1.0], 0.0, 0.0));
+        m.channels
+            .insert(1, channel(vec![1.0; 4], Some(16.0), [0.0, 0.0, 2.0], true));
+        let mut data = [0.0; 2];
+        mix(&mut m, &mut data, 2, 48_000);
+        assert!(
+            data[0] > 0.5 && (data[0] - data[1]).abs() < 1e-4,
+            "{data:?}"
+        );
+        // Alone, P1 would not hear it: 100 blocks past its 16.
+        m.listeners.clear();
+        let mut data = [0.0; 2];
+        mix(&mut m, &mut data, 2, 48_000);
+        assert_eq!(data, [0.0; 2]);
+    }
+
+    #[test]
+    fn a_shared_listener_registers_even_in_the_hosts_world() {
+        let mut host = Audio::silent(Path::new("/nonexistent/horizon-test-audio"));
+        host.set_world("minecraft:overworld");
+        let mut guest = host.share(1);
+        guest.set_world("minecraft:overworld");
+        guest.set_listener([1.0, 2.0, 3.0], 0.0, 0.0);
+        let id = guest.backend.create(false).unwrap();
+        let mixer = host.backend.mixer.lock().unwrap();
+        let overworld = mixer
+            .world_names
+            .iter()
+            .position(|w| w == "minecraft:overworld");
+        let overworld = overworld.map(|i| i as u32 + 1);
+        assert_eq!(mixer.worlds.get(&1).copied(), overworld);
+        assert_eq!(Some(mixer.channels[&id].world), overworld);
+    }
+
+    #[test]
+    fn cameras_in_other_dimensions_cannot_hear_a_source() {
+        let mut m = Mixer {
+            listener: [100.0, 0.0, 0.0],
+            ..Default::default()
+        };
+        m.listeners.insert(1, ([0.0, 0.0, 1.0], 0.0, 0.0));
+        let nether = m.world_id("nether");
+        m.worlds.insert(1, nether);
+        m.channels
+            .insert(1, channel(vec![1.0; 4], Some(16.0), [0.0, 0.0, 2.0], true));
+        let mut data = [0.0; 2];
+        mix(&mut m, &mut data, 2, 48_000);
+        assert_eq!(
+            data, [0.0; 2],
+            "nearby Nether camera must not hear Overworld source"
+        );
+        m.channels.get_mut(&1).unwrap().world = nether;
+        mix(&mut m, &mut data, 2, 48_000);
+        assert!(data[0] > 0.5, "same-world camera must hear source");
+        let end = m.world_id("end");
+        m.worlds.insert(1, end);
+        data.fill(0.0);
+        mix(&mut m, &mut data, 2, 48_000);
+        assert_eq!(data, [0.0; 2], "no listener remains in source's world");
+    }
+
+    #[test]
+    fn sounds_in_a_world_without_listeners_finish_while_inaudible() {
+        let mut mixer = Mixer::default();
+        let mut source = channel(vec![1.0; 4], None, [0.0; 3], false);
+        let nether = mixer.world_id("nether");
+        source.world = nether;
+        mixer.channels.insert(1, source);
+        let mut data = [0.0; 4];
+        mix(&mut mixer, &mut data, 2, 48_000);
+        assert_eq!(data, [0.0; 4]);
+        assert!(mixer.channels[&1].position > 0.0);
+        mix(&mut mixer, &mut data, 2, 48_000);
+        assert_eq!(mixer.channels[&1].state, State::Stopped);
+        mixer.worlds.insert(0, nether);
+        mix(&mut mixer, &mut data, 2, 48_000);
+        assert_eq!(data, [0.0; 4], "returning must not resume the old one-shot");
+    }
+
+    #[test]
+    fn variants_of_one_sound_are_the_same_sound() {
+        assert_eq!(
+            variantless("minecraft:mob/creeper/say1.ogg"),
+            "minecraft:mob/creeper/say"
+        );
+        assert_eq!(
+            variantless("minecraft:step/grass6.ogg"),
+            "minecraft:step/grass"
+        );
+        assert_eq!(
+            variantless("minecraft:random/click.ogg"),
+            "minecraft:random/click"
+        );
+    }
+
+    #[test]
+    fn another_players_copy_of_a_sound_is_dropped() {
+        let mixer = Arc::new(Mutex::new(Mixer::default()));
+        // One other player shares the output.
+        let shares = Arc::new(std::sync::atomic::AtomicUsize::new(1));
+        let backend = |owner| MixerBackend {
+            mixer: mixer.clone(),
+            root: PathBuf::new(),
+            cache: Arc::default(),
+            decoder: None,
+            next: (u64::from(owner)) << 40,
+            live: true,
+            owner,
+            world: 0,
+            shares: shares.clone(),
+        };
+        let (mut p1, mut p2) = (backend(0), backend(1));
+        // P2 is listening (its camera is in the mixer), so two players share the speakers.
+        mixer
+            .lock()
+            .unwrap()
+            .listeners
+            .insert(1, ([0.0; 3], 0.0, 0.0));
+        let started = |b: &mut MixerBackend, at: [f64; 3]| {
+            let id = b.create(false).unwrap();
+            b.set_position(id, at);
+            !b.duplicate(id, ("minecraft", "mob/creeper/say1.ogg"))
+        };
+        assert!(started(&mut p1, [5.0, 64.0, 5.0]));
+        // P2's client got the same sound at the same place: one copy plays.
+        assert!(!started(&mut p2, [5.2, 64.0, 5.0]));
+        // Elsewhere, or P1's own second one, it is a sound of its own.
+        assert!(started(&mut p2, [40.0, 64.0, 5.0]));
+        assert!(started(&mut p1, [5.0, 64.0, 5.0]));
+        // Equal coordinates in another dimension describe a different sound.
+        p2.world = mixer.lock().unwrap().world_id("nether");
+        assert!(started(&mut p2, [5.0, 64.0, 5.0]));
+        // P2 leaving takes its sounds.
+        drop(p2);
+        assert!(
+            mixer
+                .lock()
+                .unwrap()
+                .channels
+                .values()
+                .all(|c| c.owner == 0)
+        );
+    }
+
+    #[test]
+    fn reusing_a_seat_does_not_reuse_its_channels_or_leave_its_camera() {
+        let host = Audio::silent(Path::new("/nonexistent/horizon-test-audio"));
+        let mut guest = host.share(1);
+        guest.set_world("overworld");
+        guest.set_listener([1.0, 0.0, 0.0], 0.0, 0.0);
+        let old = guest.backend.create(false).unwrap();
+        drop(guest);
+        {
+            let mixer = host.backend.mixer.lock().unwrap();
+            assert!(!mixer.channels.contains_key(&old));
+            assert!(!mixer.listeners.contains_key(&1));
+            assert!(!mixer.worlds.contains_key(&1));
+        }
+        let mut replacement = host.share(1);
+        let new = replacement.backend.create(false).unwrap();
+        assert_ne!(old, new);
+        assert!(
+            replacement
+                .backend
+                .mixer
+                .lock()
+                .unwrap()
+                .channels
+                .contains_key(&new)
+        );
+    }
+
    #[test]
    fn a_mono_output_plays_sources_unpanned() {
        let mut m = Mixer::default();
@@ -1306,4 +1809,15 @@ mod tests {
        mix(&mut m, &mut data, 1, 48_000);
        assert_eq!(data, [0.5; 2]);
    }
+
+    #[test]
+    fn output_devices_are_looked_at_again_only_when_the_cards_change() {
+        // No fingerprint (not Linux, or the cards could not be read): the list
+        // has to be looked at as before.
+        assert!(cards_changed(None, None));
+        assert!(cards_changed(Some("0 [PCH ]"), None));
+        // The same cards list the same devices; a card added or removed does not.
+        assert!(!cards_changed(Some("0 [PCH ]"), Some("0 [PCH ]")));
+        assert!(cards_changed(Some("0 [PCH ]"), Some("0 [PCH ]\n 1 [USB ]")));
+    }
 }
@@ -272,6 +272,211 @@ pub fn join_server(session: &AuthSession, server_hash: &str) -> Result<(), JoinE
    }
 }

+/// The account's chat key pair (ProfileKeyPair): the private key that signs
+/// its chat, the public key with the services' signature over it, and when
+/// to fetch a new one (refreshedAfter, epoch milliseconds). Like the access
+/// token it stays in memory: vanilla's profilekeys file is never written.
+pub struct ChatKeyPair {
+    pub private: horizon_protocol::rsa::RsaPrivateKey,
+    pub public: horizon_protocol::secure_chat::ProfileKey,
+    pub refreshed_after: i64,
+}
+impl std::fmt::Debug for ChatKeyPair {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ChatKeyPair")
+            .field("expires_at", &self.public.expires_at)
+            .field("refreshed_after", &self.refreshed_after)
+            .finish_non_exhaustive()
+    }
+}
+impl ChatKeyPair {
+    /// ProfileKeyPair.dueRefresh.
+    pub fn due_refresh(&self, now: i64) -> bool {
+        self.refreshed_after < now
+    }
+}
+
+/// Epoch milliseconds now.
+pub fn now_millis() -> i64 {
+    SystemTime::now()
+        .duration_since(SystemTime::UNIX_EPOCH)
+        .map_or(0, |d| d.as_millis() as i64)
+}
+
+/// Instant.parse for the services' UTC times
+/// (`2022-07-30T23:05:24.548227Z`): epoch milliseconds.
+pub fn parse_instant(text: &str) -> Option<i64> {
+    let text = text.strip_suffix('Z')?;
+    let (date, time) = text.split_once('T')?;
+    let mut date = date.splitn(3, '-').map(|p| p.parse::<i64>().ok());
+    let (y, m, d) = (date.next()??, date.next()??, date.next()??);
+    let (hms, fraction) = time.split_once('.').unwrap_or((time, ""));
+    let mut hms = hms.splitn(3, ':').map(|p| p.parse::<i64>().ok());
+    let (h, min, s) = (hms.next()??, hms.next()??, hms.next()??);
+    if !(1..=12).contains(&m) || !(1..=31).contains(&d) || h > 23 || min > 59 || s > 60 {
+        return None;
+    }
+    if !fraction.bytes().all(|b| b.is_ascii_digit()) {
+        return None;
+    }
+    let millis = format!("{fraction:0<3}")[..3].parse::<i64>().ok()?;
+    // Days from 1970-01-01 (Howard Hinnant's days_from_civil).
+    let y = if m <= 2 { y - 1 } else { y };
+    let era = y.div_euclid(400);
+    let yoe = y - era * 400;
+    let doy = (153 * (m + if m > 2 { -3 } else { 9 }) + 2) / 5 + d - 1;
+    let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+    let days = era * 146_097 + doe - 719_468;
+    Some(((days * 24 + h) * 60 + min) * 60_000 + s * 1000 + millis)
+}
+
+/// Crypt.stringToPemRsaPrivateKey / stringToRsaPublicKey: the base64
+/// between a PEM block's armour lines.
+fn pem_der(pem: &str) -> Option<Vec<u8>> {
+    let body: String = pem
+        .lines()
+        .filter(|l| !l.starts_with("-----"))
+        .flat_map(|l| l.chars().filter(|c| !c.is_whitespace()))
+        .collect();
+    crate::skins::base64_decode(&body)
+}
+
+/// KeyPairResponse from the certificates endpoint, as
+/// AccountProfileKeyPairManager.fetchProfileKeyPair reads it: the PEM key
+/// pair, publicKeySignatureV2 (the signature over the profile id too),
+/// expiresAt and refreshedAfter. None for anything malformed, or a private
+/// key that isn't the public key's other half.
+pub fn parse_certificates(body: &str) -> Option<ChatKeyPair> {
+    use horizon_protocol::rsa::{RsaPrivateKey, RsaPublicKey};
+    let v: serde_json::Value = serde_json::from_str(body).ok()?;
+    let field = |path: &str| v.pointer(path).and_then(|s| s.as_str());
+    let private = RsaPrivateKey::from_der(&pem_der(field("/keyPair/privateKey")?)?).ok()?;
+    let key = pem_der(field("/keyPair/publicKey")?)?;
+    if RsaPublicKey::from_der(&key).ok()? != private.public {
+        return None;
+    }
+    let signature = crate::skins::base64_decode(field("/publicKeySignatureV2")?)?;
+    Some(ChatKeyPair {
+        private,
+        public: horizon_protocol::secure_chat::ProfileKey {
+            expires_at: parse_instant(field("/expiresAt")?)?,
+            key,
+            signature,
+        },
+        refreshed_after: parse_instant(field("/refreshedAfter")?)?,
+    })
+}
+
+/// UserApiService.getKeyPair: the certificates endpoint, POSTed with the
+/// access token.
+pub fn fetch_chat_keys(session: &AuthSession) -> Result<ChatKeyPair, JoinError> {
+    let doc = discovery()?;
+    let url = endpoint(&doc, "player", "getCertificates").ok_or(JoinError::Unavailable)?;
+    let body = match agent()
+        .post(&url)
+        .set("Authorization", &format!("Bearer {}", session.access_token))
+        .set("Content-Type", "application/json; charset=utf-8")
+        .send_string("")
+    {
+        Ok(response) => response.into_string().unwrap_or_default(),
+        Err(ureq::Error::Status(status, response)) => {
+            return Err(JoinError::from_response(
+                status,
+                &response.into_string().unwrap_or_default(),
+            ));
+        }
+        Err(ureq::Error::Transport(_)) => return Err(JoinError::Unavailable),
+    };
+    parse_certificates(&body)
+        .ok_or_else(|| JoinError::Other("Malformed profile key pair response".to_owned()))
+}
+
+/// AccountProfileKeyPairManager.MINIMUM_PROFILE_KEY_REFRESH_INTERVAL.
+const KEY_RETRY: Duration = Duration::from_secs(60 * 60);
+
+/// The chat key pair as AccountProfileKeyPairManager keeps it: fetched on a
+/// background thread, kept until it is due a refresh, and on a failure kept
+/// as it was (the next try waits an hour, or the next join).
+#[derive(Default)]
+struct ChatKeys {
+    current: Option<Arc<ChatKeyPair>>,
+    fetching: bool,
+    next_try: Option<std::time::Instant>,
+}
+static CHAT_KEYS: Mutex<ChatKeys> = Mutex::new(ChatKeys {
+    current: None,
+    fetching: false,
+    next_try: None,
+});
+
+/// prepareKeyPair (`now`: on a join) or, from a tick, shouldRefreshKeyPair
+/// then prepareKeyPair: start fetching when there is no key pair or it is
+/// due a refresh. Nothing without a signed-in account.
+pub fn prepare_chat_keys(now: bool) {
+    let Some(session) = current() else {
+        return;
+    };
+    let mut keys = CHAT_KEYS.lock().unwrap();
+    let instant = std::time::Instant::now();
+    if keys.fetching || !now && keys.next_try.is_some_and(|t| instant < t) {
+        return;
+    }
+    keys.next_try = Some(instant + KEY_RETRY);
+    if keys
+        .current
+        .as_ref()
+        .is_some_and(|k| !k.due_refresh(now_millis()))
+    {
+        return;
+    }
+    keys.fetching = true;
+    drop(keys);
+    let spawned = std::thread::Builder::new()
+        .name("Profile key fetch".into())
+        .spawn(move || {
+            let result = fetch_chat_keys(&session);
+            let mut keys = CHAT_KEYS.lock().unwrap();
+            keys.fetching = false;
+            match result {
+                Ok(pair) => keys.current = Some(Arc::new(pair)),
+                Err(e) => log::error!("Failed to retrieve profile key pair: {e:?}"),
+            }
+        });
+    if spawned.is_err() {
+        CHAT_KEYS.lock().unwrap().fetching = false;
+    }
+}
+
+/// The chat key pair fetched so far, unless it has expired.
+pub fn chat_keys() -> Option<Arc<ChatKeyPair>> {
+    let now = now_millis();
+    CHAT_KEYS
+        .lock()
+        .unwrap()
+        .current
+        .clone()
+        .filter(|k| !k.public.has_expired(now))
+}
+
+const MINECRAFT_PROFILE: &str = "https://api.minecraftservices.com/minecraft/profile";
+
+/// The signed-in account's active skin and cape from `GET /minecraft/profile`.
+/// Single-player and integrated servers often send no `textures` property, or
+/// one without the equipped cape; the client asks the profile endpoint once.
+pub fn own_textures(session: &AuthSession) -> Option<crate::skins::Textures> {
+    let response = agent()
+        .get(MINECRAFT_PROFILE)
+        .set("Authorization", &format!("Bearer {}", session.access_token))
+        .call()
+        .ok()?;
+    if response.status() != 200 {
+        return None;
+    }
+    let body = response.into_string().ok()?;
+    let profile: serde_json::Value = serde_json::from_str(&body).ok()?;
+    Some(crate::skins::services_profile_textures(&profile))
+}
+
 /// What the session service says about a player joining this server
 /// (MinecraftServicesSessionService.hasJoinedServer).
 #[derive(Clone, Debug, PartialEq)]
@@ -466,6 +671,104 @@ mod tests {
        );
    }

+    #[test]
+    fn instants_like_java() {
+        assert_eq!(parse_instant("1970-01-01T00:00:00Z"), Some(0));
+        assert_eq!(parse_instant("1970-01-01T00:00:01.5Z"), Some(1500));
+        // Instant.parse("2022-07-30T23:05:24.548227Z").toEpochMilli().
+        assert_eq!(
+            parse_instant("2022-07-30T23:05:24.548227Z"),
+            Some(1_659_222_324_548)
+        );
+        assert_eq!(
+            parse_instant("2024-02-29T12:00:00Z"),
+            Some(1_709_208_000_000)
+        );
+        assert_eq!(parse_instant("1969-12-31T23:59:59Z"), Some(-1000));
+        for bad in [
+            "2022-07-30T23:05:24",
+            "2022-13-01T00:00:00Z",
+            "2022-07-30 23:05:24Z",
+            "2022-07-30T23:05:24.5x1Z",
+            "",
+        ] {
+            assert_eq!(parse_instant(bad), None, "{bad}");
+        }
+    }
+
+    /// A throwaway 1024-bit key (`openssl genrsa`, PKCS#8 as the services
+    /// send it under "RSA PRIVATE KEY") and its public half.
+    const PRIVATE_B64: &str = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKSDqaLOF2Ltt4tzWblkFeNYhdss67BhXTbOMUYjpcPdtf4dzNtgZsTf4WEluvc8pItGWChdpq3xzPC9GL4PZ+Oh1o6VR/wSm20/50QT7V+YcSP1VrVKjDpDSg/UoC1Fmdc/vb9AO8Ip7TxuRYd/uyog/ThQ8aGcWtvvtwPqx4XrAgMBAAECgYA+ZGy2gQDflRZSPeoeZHXkphMF/7BXUWW/vk1zs1tPwEsgV/70iEgRjHL2nA+fapFg/Mm8bWAkghrehmjW1BLq5w8sGdGJCHfE/kauu78jJK0/ME38e9bsSEvv5HMMxyx0mlV8DQu2pzCT71ceT8VD/1pewUbpeZypj5pxtsCIMQJBANXgca/mnAQXTuowI8FqMiald6OuAcAWbOaNrCB5HHWuxH7hFatSqGrgp4YLqHv7bzeodU1y/uxwc+/01khd0rMCQQDE6mPfIdZxHhWkMUAKhMEnrLanfCL0dfyAe+lBpqgPwO3UurCfCaFX5RdYB3fCyvgy5foHN1/I8/Eobp+enrvpAkBgkZnjeXWiZz/Lf/b1AtUoG/g8IHpL2BRNuVQpyWVvQX0ZaNoW5BiFQXCClsr5SBr8f4SPdsfhzBidFOiX/jz/AkBDuk6Bd3T3UR6ma54YQBLjX38vWf330QD4/CV9RCH30Sa8DT4kZT6OKah+yYrCf+cgMoNtqfkS9/xRKMNT3krJAkAaFrAT6HF5Y9b5OLASbbFe7MZ4zNCzuEl6plKNUi+JCHESaU/VCCuYOLoWLeSDFYkZUoSmqiRxH8fVTsBz393x";
+    const PUBLIC_B64: &str = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCkg6mizhdi7beLc1m5ZBXjWIXbLOuwYV02zjFGI6XD3bX+HczbYGbE3+FhJbr3PKSLRlgoXaat8czwvRi+D2fjodaOlUf8EpttP+dEE+1fmHEj9Va1Sow6Q0oP1KAtRZnXP72/QDvCKe08bkWHf7sqIP04UPGhnFrb77cD6seF6wIDAQAB";
+
+    fn pem(label: &str, b64: &str) -> String {
+        let lines: Vec<&str> = b64
+            .as_bytes()
+            .chunks(76)
+            .map(|c| std::str::from_utf8(c).unwrap())
+            .collect();
+        format!(
+            "-----BEGIN {label}-----\n{}\n-----END {label}-----\n",
+            lines.join("\n")
+        )
+    }
+
+    fn certificates(private: &str, public: &str) -> String {
+        serde_json::json!({
+            "keyPair": {
+                "privateKey": pem("RSA PRIVATE KEY", private),
+                "publicKey": pem("RSA PUBLIC KEY", public),
+            },
+            "publicKeySignature": "djE=",
+            "publicKeySignatureV2": "c2ln",
+            "expiresAt": "2022-07-30T23:05:24.548227Z",
+            "refreshedAfter": "2022-07-30T15:05:24.548227Z",
+        })
+        .to_string()
+    }
+
+    #[test]
+    fn certificates_response() {
+        let pair = parse_certificates(&certificates(PRIVATE_B64, PUBLIC_B64)).unwrap();
+        assert_eq!(
+            pair.public.key,
+            crate::skins::base64_decode(PUBLIC_B64).unwrap()
+        );
+        assert_eq!(pair.public.signature, b"sig", "publicKeySignatureV2");
+        assert_eq!(pair.public.expires_at, 1_659_222_324_548);
+        assert_eq!(pair.refreshed_after, 1_659_193_524_548);
+        assert_eq!(pair.private.public_der(), pair.public.key);
+        assert!(pair.due_refresh(1_659_193_524_549));
+        assert!(!pair.due_refresh(1_659_193_524_548));
+        assert!(!format!("{pair:?}").contains("MII"));
+        // A public key that isn't the private key's, and broken fields.
+        let other = horizon_protocol::rsa::RsaPrivateKey::generate(1024).unwrap();
+        let other = base64(&other.public_der());
+        assert!(parse_certificates(&certificates(PRIVATE_B64, &other)).is_none());
+        assert!(parse_certificates(&certificates("bm9wZQ==", PUBLIC_B64)).is_none());
+        assert!(parse_certificates("{}").is_none());
+        assert!(parse_certificates("").is_none());
+    }
+
+    fn base64(bytes: &[u8]) -> String {
+        const A: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        let mut out = String::new();
+        for c in bytes.chunks(3) {
+            let n = c
+                .iter()
+                .enumerate()
+                .fold(0u32, |n, (i, &b)| n | u32::from(b) << (16 - 8 * i));
+            for i in 0..4 {
+                out.push(if i <= c.len() {
+                    char::from(A[(n >> (18 - 6 * i) & 63) as usize])
+                } else {
+                    '='
+                });
+            }
+        }
+        out
+    }
+
    #[test]
    fn discovery_endpoints() {
        let doc = serde_json::json!({"discovery": {"session": {"endpoints": {"join": {"uri": "https://s/join"}}}}});
@@ -23,7 +23,7 @@
 //! Which states tick is a table by state id, built by the game from the block
 //! registry; whether a slot is made is decided when the slot is promoted at
 //! the start of the next tick, from the block state then.
-use crate::chunk::block_entity::{BlockEntity, ModContainer};
+use crate::chunk::block_entity::{BlockEntity, ModContainer, ModFluidTanks};
 use crate::fast_hash::{FxHashMap, FxHashSet};
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -73,6 +73,9 @@ pub struct BlockEntities {
    /// The containers of mod blocks' block entities, by block state id;
    /// built with `states`.
    mod_containers: FxHashMap<u32, Arc<ModContainer>>,
+    /// The fluid tanks of mod blocks' block entities, by block state id;
+    /// built with `states`, like the containers.
+    mod_fluids: FxHashMap<u32, Arc<ModFluidTanks>>,
 }

 impl std::ops::Deref for BlockEntities {
@@ -162,6 +165,13 @@ impl BlockEntities {
    pub fn mod_container(&self, state: u32) -> Option<&Arc<ModContainer>> {
        self.mod_containers.get(&state)
    }
+    pub fn set_mod_fluids(&mut self, fluids: FxHashMap<u32, Arc<ModFluidTanks>>) {
+        self.mod_fluids = fluids;
+    }
+    /// The fluid tanks of a mod block's block entity in block state `state`.
+    pub fn mod_fluids(&self, state: u32) -> Option<&Arc<ModFluidTanks>> {
+        self.mod_fluids.get(&state)
+    }

    fn next(&mut self) -> u32 {
        let n = self.next_slot;
@@ -1118,9 +1118,10 @@ impl BlockEntityRenderer {
    }
    /// `submitCrumblingOverlay` of ChestRenderer.submit, BannerRenderer.submit,
    /// SkullBlockRenderer.submitSkull, ShulkerBoxRenderer.submit,
-    /// BellRenderer.submit, LecternRenderer.submit (the book) and
-    /// CopperGolemStatueBlockRenderer.submit: the model drawn again under the
-    /// destroy stage.
+    /// BellRenderer.submit, LecternRenderer.submit (the book),
+    /// CopperGolemStatueBlockRenderer.submit, ConduitRenderer.submit (the shell
+    /// or cage) and EnchantTableRenderer.submit (the book): the model drawn
+    /// again under the destroy stage.
    pub fn render_breaking(
        &self,
        scene: &Scene,
@@ -1138,6 +1139,8 @@ impl BlockEntityRenderer {
                | Kind::Bell
                | Kind::Lectern { .. }
                | Kind::CopperGolem { .. }
+                | Kind::Conduit
+                | Kind::EnchantingTable
        ) {
            return;
        }
@@ -1683,6 +1686,10 @@ impl BlockEntityRenderer {
                        * Mat4::from_quat(Quat::from_axis_angle(axis, degrees * (PI / 180.0)));
                    draw_part(model, "root", m, &none, paint, out);
                }
+                // The crumbling overlay covers the shell and the cage only.
+                if crumbling {
+                    return;
+                }
                let wind = if phase == 1 {
                    "entity/conduit/wind_vertical"
                } else {
@@ -13,7 +13,8 @@ use std::{collections::HashSet, fs, path::Path};

 pub use horizon_client_core::potions::{
    BASE_POTION_COLOR, Category, EFFECTS, EffectDef, POTIONS, PotionDef, all_effects,
-    description_id, effect, mod_effects, namespaced, potion, potion_color, register_mod_effects,
+    description_id, effect, is_mod_effect, mod_effects, namespaced, potion, potion_color,
+    register_mod_effects,
 };
 /// `MobEffectUtil.formatDuration` at 20 TPS.
 pub fn format_duration(ticks: i32) -> String {
@@ -434,6 +434,10 @@ pub struct Camera {
    pub up: [f32; 3],
    pub left: [f32; 3],
    pub detached: bool,
+    /// The entity's eye and view rotation (yaw, pitch), where a detached camera backs off
+    /// from.
+    pub eye: [f64; 3],
+    pub eye_rotation: [f32; 2],
 }
 impl Default for Camera {
    fn default() -> Self {
@@ -450,6 +454,8 @@ impl Default for Camera {
            up: [0.0, 1.0, 0.0],
            left: [-1.0, 0.0, 0.0],
            detached: false,
+            eye: [0.0; 3],
+            eye_rotation: [0.0; 2],
        }
    }
 }
@@ -505,6 +511,8 @@ impl Camera {
                + f64::from(lerp(partial, self.eye_height_old, self.eye_height)),
            lerp_d(p, entity.previous[2], entity.position[2]),
        ];
+        self.eye = self.position;
+        self.eye_rotation = [self.y_rot, self.x_rot];
        self.detached = !camera_type.is_first_person();
        if self.detached {
            if camera_type.is_mirrored() {
@@ -210,6 +210,14 @@ impl Tag {
            text: Text::translate("chat.tag.not_secure", &[]),
        }
    }
+    /// `GuiMessageTag.chatError`: red (`CHAT_ERROR`, 16733525), the tooltip `chat.tag.error`.
+    pub fn chat_error() -> Self {
+        Self {
+            color: 0xFF_5555,
+            icon: false,
+            text: Text::translate("chat.tag.error", &[]),
+        }
+    }
    /// `GuiMessageTag.chatModified`: the tooltip adds the original content in grey.
    pub fn modified(original_content: &str) -> Self {
        Self {
@@ -870,6 +878,22 @@ impl Chat {
    }
 }

+/// `SuggestionsList.getNarrationMessage` for entry `index` of `count`.
+fn suggestion_narration(index: usize, count: usize, text: &str, tooltip: Option<&str>) -> Text {
+    let mut args = vec![
+        Text::literal((index + 1).to_string()),
+        Text::literal(count.to_string()),
+        Text::literal(text),
+    ];
+    match tooltip {
+        Some(tooltip) => {
+            args.push(Text::literal(tooltip));
+            Text::translate("narration.suggestion.tooltip", &args)
+        }
+        None => Text::translate("narration.suggestion", &args),
+    }
+}
+
 /// `CommandSuggestions.SuggestionsList`.
 #[derive(Clone, Debug)]
 struct SuggestionList {
@@ -881,8 +905,17 @@ struct SuggestionList {
    current: usize,
    last_mouse: (i32, i32),
    tab_cycles: bool,
+    /// `lastNarratedEntry`: the entry the narrator last said (-1: none yet).
+    last_narrated: isize,
 }
 impl SuggestionList {
+    /// `getNarrationMessage`: "Selected suggestion 2 out of 5: …", with its
+    /// tooltip when it has one. It marks the entry said.
+    fn narration_message(&mut self) -> Text {
+        self.last_narrated = self.current as isize;
+        let s = &self.list[self.current];
+        suggestion_narration(self.current, self.list.len(), &s.text, s.tooltip.as_deref())
+    }
    fn contains(&self, x: i32, y: i32) -> bool {
        let [rx, ry, w, h] = self.rect;
        x >= rx && x <= rx + w && y >= ry && y <= ry + h
@@ -1005,6 +1038,53 @@ fn last_word_index(s: &str) -> usize {
    }
    if prev_space { s.len() } else { out }
 }
+/// `ChatScreen.normalizeChatMessage`: `String.trim`, then
+/// `StringUtils.normalizeSpace` (one space for every run of whitespace), then
+/// `StringUtil.trimChatMessage` (the first 256 UTF-16 code units, the length
+/// `ServerboundChatPacket`'s `stringUtf8(256)` decodes). The chat screen sends
+/// this, not what was typed: a line of spaces sends nothing, and a message the
+/// packet cannot hold is cut on the client, as vanilla's is, instead of by the
+/// server.
+pub fn normalize_chat_message(message: &str) -> String {
+    // String.trim: the code points up to U+0020, which is not `str::trim`'s
+    // Unicode whitespace (U+00A0 is not Java whitespace and stays).
+    let trimmed = message.trim_matches(|c: char| c <= ' ');
+    truncate_utf16(&normalize_space(trimmed), 256)
+}
+/// `StringUtils.normalizeSpace`: one space for every run of
+/// `Character.isWhitespace`, and none at either end.
+fn normalize_space(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    let mut space = false;
+    for c in s.chars() {
+        if crate::ui::java_whitespace(c) {
+            space = !out.is_empty();
+        } else {
+            if space {
+                out.push(' ');
+                space = false;
+            }
+            out.push(c);
+        }
+    }
+    out
+}
+/// `StringUtil.truncateStringIfNecessary(s, 256, false)`: Java counts UTF-16
+/// code units (`String.length`), so 129 emoji are cut to 128 of them, where
+/// `chars().take(256)` would keep all 129 (258 units) for the server to
+/// reject. A cut between the halves of a surrogate pair keeps the character
+/// below it: vanilla's `substring` leaves half a pair, which a Java `String`
+/// may hold and a Rust `String` may not.
+fn truncate_utf16(s: &str, max_units: usize) -> String {
+    let mut units = 0;
+    for (byte, c) in s.char_indices() {
+        units += c.len_utf16();
+        if units > max_units {
+            return s[..byte].to_owned();
+        }
+    }
+    s.to_owned()
+}
 impl ChatScreen {
    /// `ChatScreen.init`: the input at the bottom, focused, holding `initial`.
    pub fn new(
@@ -1094,12 +1174,14 @@ impl ChatScreen {
            let value = self.input.value.clone();
            let auto = self.auto_suggestions;
            let abilities = self.abilities;
+            let message = std::mem::take(&mut self.input.message);
            *self = if self.layout == SuggestLayout::CHAT {
                Self::new(m, c, &value, self.history_pos, width, height, abilities)
            } else {
                Self::command_block(m, c, &value, width, height)
            };
            self.auto_suggestions = auto;
+            self.input.message = message;
        }
    }
    /// `ChatScreen.onEdited`.
@@ -1323,11 +1405,12 @@ impl ChatScreen {
        };
        self.suggestions = None;
        if self.allow_suggestions && self.auto_suggestions {
-            self.show_suggestions(m);
+            self.show_suggestions(m, false);
        }
    }
-    /// `CommandSuggestions.showSuggestions`.
-    fn show_suggestions(&mut self, m: &Measure) {
+    /// `CommandSuggestions.showSuggestions`: `immediate` (Tab asked for
+    /// them) has the narrator say the first one at once.
+    fn show_suggestions(&mut self, m: &Measure, immediate: bool) {
        let Some((start, list)) = self.pending.clone() else {
            return;
        };
@@ -1370,6 +1453,7 @@ impl ChatScreen {
            current: 0,
            last_mouse: (0, 0),
            tab_cycles: false,
+            last_narrated: if immediate { -1 } else { 0 },
        };
        self.select(&mut l, 0);
        self.suggestions = Some(l);
@@ -1389,6 +1473,9 @@ impl ChatScreen {
        self.input.suggestion = applied
            .strip_prefix(self.input.value.as_str())
            .map(str::to_owned);
+        if l.last_narrated != l.current as isize {
+            horizon_narrator::say_system_now(&l.narration_message().plain());
+        }
    }
    fn cycle(&mut self, l: &mut SuggestionList, dir: isize) {
        self.select(l, l.current as isize + dir);
@@ -1499,7 +1586,7 @@ impl ChatScreen {
            self.suggestions = Some(l);
            handled
        } else if key == K::Tab {
-            self.show_suggestions(m);
+            self.show_suggestions(m, true);
            true
        } else {
            false
@@ -1732,4 +1819,18 @@ impl ChatScreen {
    pub fn suggestions_visible(&self) -> bool {
        self.suggestions.is_some()
    }
+    /// `CommandSuggestions.getUsageNarration` while the list shows
+    /// (`isVisible`): whether Tab cycles it or fills the input in, and
+    /// whether Escape hides it (`allowHiding`, which only the chat's turns
+    /// off).
+    pub fn suggestions_usage(&self) -> Option<&'static str> {
+        let list = self.suggestions.as_ref()?;
+        let hidable = self.layout != SuggestLayout::CHAT;
+        Some(match (list.tab_cycles, hidable) {
+            (true, true) => "narration.suggestion.usage.cycle.hidable",
+            (true, false) => "narration.suggestion.usage.cycle.fixed",
+            (false, true) => "narration.suggestion.usage.fill.hidable",
+            (false, false) => "narration.suggestion.usage.fill.fixed",
+        })
+    }
 }
@@ -578,3 +578,71 @@ fn a_deleted_message_shows_60_ticks_then_becomes_the_marker() {
    assert_eq!(lines(&chat), [marker.clone(), marker]);
    assert!(chat.deletions.is_empty());
 }
+
+/// `SuggestionsList.select` says an entry once (`lastNarratedEntry`), as
+/// "suggestion N out of M", with its tooltip when it has one.
+#[test]
+fn a_suggestion_is_narrated_by_its_place_once() {
+    let suggestion = |text: &str, tooltip: Option<&str>| Suggestion {
+        range: (1, 1),
+        text: text.into(),
+        tooltip: tooltip.map(str::to_owned),
+        int_value: None,
+    };
+    let mut l = SuggestionList {
+        rect: [0; 4],
+        original: "/".into(),
+        list: vec![
+            suggestion("give", None),
+            suggestion("gamemode", Some("Mode")),
+        ],
+        offset: 0,
+        current: 1,
+        last_mouse: (0, 0),
+        tab_cycles: false,
+        last_narrated: 0,
+    };
+    let said = l.narration_message().component();
+    assert_eq!(l.last_narrated, 1);
+    assert_eq!(said["translate"], "narration.suggestion.tooltip");
+    assert_eq!(said["with"].as_array().map(Vec::len), Some(4));
+    l.current = 0;
+    let said = l.narration_message().component();
+    assert_eq!(said["translate"], "narration.suggestion");
+    assert_eq!(said["with"].as_array().map(Vec::len), Some(3));
+}
+
+#[test]
+fn a_chat_message_is_trimmed_and_its_whitespace_runs_collapsed() {
+    // ChatScreen.normalizeChatMessage: String.trim, then StringUtils
+    // .normalizeSpace, so a command gets the arguments the player meant.
+    assert_eq!(normalize_chat_message("  hello   there  "), "hello there");
+    assert_eq!(normalize_chat_message("/msg  Alex\thi"), "/msg Alex hi");
+    assert_eq!(normalize_chat_message("a\n\nb\r\nc"), "a b c");
+    assert_eq!(normalize_chat_message("\t \n"), "");
+    assert_eq!(normalize_chat_message(""), "");
+    // Character.isWhitespace is not str::trim's Unicode whitespace: U+00A0 is
+    // no Java whitespace, so it is neither trimmed nor collapsed, while the
+    // ideographic space U+3000 and Java's U+001C separators are.
+    assert_eq!(normalize_chat_message(" \u{a0} hi"), "\u{a0} hi");
+    assert_eq!(normalize_chat_message("a\u{a0}\u{a0}b"), "a\u{a0}\u{a0}b");
+    assert_eq!(normalize_chat_message("a\u{3000}\u{3000}b"), "a b");
+    assert_eq!(normalize_chat_message("a\u{1c}b"), "a b");
+}
+
+#[test]
+fn a_chat_message_is_cut_to_the_256_utf16_units_the_packet_holds() {
+    // StringUtil.trimChatMessage counts String.length(), UTF-16 code units:
+    // 256 ASCII characters are all kept, 257 are cut to 256.
+    assert_eq!(normalize_chat_message(&"a".repeat(256)).len(), 256);
+    assert_eq!(normalize_chat_message(&"a".repeat(300)).len(), 256);
+    // An emoji is two units, so 128 of them fill the packet and the 129th is
+    // dropped: chars().take(256) would keep all 129 and the server would
+    // reject the message.
+    let emoji = normalize_chat_message(&"\u{1f600}".repeat(129));
+    assert_eq!(emoji, "\u{1f600}".repeat(128));
+    assert_eq!(emoji.encode_utf16().count(), 256);
+    // A cut between the halves of a pair keeps the character below it.
+    let mixed = format!("{}\u{1f600}", "b".repeat(255));
+    assert_eq!(normalize_chat_message(&mixed), "b".repeat(255));
+}
@@ -212,7 +212,7 @@ impl Default for ColumnLayout {

 /// Biomes are 4x4x4 containers over the biome table (67 entries: a 7-bit
 /// global palette).
-pub const BIOME_STRATEGY: Strategy = Strategy::biomes(7);
+pub const BIOME_STRATEGY: Strategy = Strategy::biomes(8);

 /// Bits of the block states' global palette: 16 for vanilla's 35,723 states
 /// (what vanilla servers and clients send), more when content mods add states
@@ -391,6 +391,9 @@ pub struct Chunk {
    pub light_loaded: bool,
    /// Newly generated (not loaded from a save): eligible for generation-time spawns.
    pub fresh: bool,
+    /// Finished from a proto chunk just now, in any kind of world, not read
+    /// from a save (`ChunkEvent.Load`'s `isNewChunk`).
+    pub generated: bool,
    /// Block entities read from a save, moved into the world on arrival.
    pub block_entities: Vec<((i32, i32, i32), block_entity::BlockEntity)>,
    /// `CustomName` of the container block entities (shown as the screen title).
@@ -428,6 +431,7 @@ impl Chunk {
            lit: false,
            light_loaded: false,
            fresh: false,
+            generated: false,
            block_entities: Vec::new(),
            block_names: Vec::new(),
            structure_refs: Vec::new(),
@@ -120,6 +120,21 @@ pub struct ModContainer {
    pub outputs: Vec<usize>,
    pub menu: Option<String>,
 }
+/// The fluid tanks of a mod block's block entity, in the container's shape:
+/// each tank's capacity in millibuckets, the tanks each face reaches, and
+/// the tanks a fill may reach and a drain may take. The tanks' contents are
+/// not here: they live in the entity's saved compound, under `fluids`, so
+/// they survive restarts and the block's own tick reads them.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct ModFluidTanks {
+    /// Each tank's capacity in millibuckets, in tank order.
+    pub tanks: Vec<i32>,
+    pub faces: [Vec<usize>; 6],
+    /// The tanks a fill may reach (`canPlaceItemThroughFace`).
+    pub inputs: Vec<usize>,
+    /// The tanks a drain may take from (`canTakeItemThroughFace`).
+    pub outputs: Vec<usize>,
+}
 /// The vanilla menus a mod container can open, with the slot count each
 /// shows: slot grids, and the furnaces' (input, fuel, result), whose four
 /// data slots draw the flame (`data[0]` of `data[1]`) and the arrow
@@ -276,11 +291,19 @@ pub struct Beacon {
 }
 #[derive(Clone, Debug, Default)]
 pub struct Jukebox {
-    pub record: Option<ItemStack>,
+    /// `JukeboxBlockEntity`'s one slot (`ContainerSingleItem`), so a hopper or
+    /// a dropper reaches it as it reaches any container.
+    pub items: [Option<ItemStack>; 1],
    /// `ticks_since_song_started`, while a song plays.
    pub ticks: i64,
    pub playing: bool,
 }
+impl Jukebox {
+    /// `JukeboxBlockEntity.getTheItem`: the disc it holds.
+    pub fn record(&self) -> Option<&ItemStack> {
+        self.items[0].as_ref()
+    }
+}
 /// `BrewingStandBlockEntity` state. Slots: 0-2 bottles, 3 ingredient, 4 fuel.
 #[derive(Clone, Debug, Default)]
 pub struct BrewingStand {
@@ -1,7 +1,13 @@
 //! Resident chunk membership, with a token for consumers that cache its keys.
-use crate::{chunk::Chunk, fast_hash::FxHashMap};
+use crate::{
+    chunk::Chunk,
+    fast_hash::{FxHashMap, FxHashSet},
+};
 use std::{
-    collections::hash_map::{Iter, ValuesMut},
+    collections::{
+        VecDeque,
+        hash_map::{Iter, ValuesMut},
+    },
    ops::Deref,
    sync::{
        Arc,
@@ -16,18 +22,46 @@ fn next_revision() -> u64 {
    NEXT_REVISION.fetch_add(1, Ordering::Relaxed)
 }

+/// The membership changes one map keeps for the consumers that read them
+/// every tick (`TickChunkMembership.synchronize`); older ones are dropped.
+const MAX_RECENT_DELTAS: usize = 256;
+
+/// One membership change of one `ChunkMap`, stamped with the revision it
+/// brought the map to.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ChunkMembershipDelta {
+    Added(Key),
+    Removed(Key),
+    Reset,
+}
+
 /// Read access behaves like a map. Structural writes are explicit so edits to
 /// blocks or light don't invalidate consumers of the loaded chunk key set.
 /// Tokens are process-wide: replacing the entire map also invalidates caches.
 pub struct ChunkMap {
    columns: Columns,
    revision: u64,
+    /// The oldest revision `recent_deltas` still answers for: the revision of
+    /// the change it last dropped, or the revision that cleared them. A
+    /// consumer holding an older one rebuilds, it does not replay.
+    min_valid_revision: u64,
+    /// This map's recent membership changes, in revision order.
+    /// Revisions are process-wide: the numbers missing in between belong to
+    /// the other maps (a server thread's, another dimension's), which say
+    /// nothing about this one's keys.
+    recent_deltas: VecDeque<(u64, ChunkMembershipDelta)>,
+    /// The resident chunks generation has not placed its animals in yet.
+    fresh: FxHashSet<Key>,
 }
 impl Default for ChunkMap {
    fn default() -> Self {
+        let revision = next_revision();
        Self {
            columns: Columns::default(),
-            revision: next_revision(),
+            revision,
+            min_valid_revision: revision,
+            recent_deltas: VecDeque::new(),
+            fresh: FxHashSet::default(),
        }
    }
 }
@@ -35,26 +69,107 @@ impl ChunkMap {
    pub fn membership_revision(&self) -> u64 {
        self.revision
    }
+    fn record_delta(&mut self, delta: ChunkMembershipDelta) {
+        if self.recent_deltas.len() >= MAX_RECENT_DELTAS
+            && let Some((evicted, _)) = self.recent_deltas.pop_front()
+        {
+            self.min_valid_revision = evicted;
+        }
+        self.recent_deltas.push_back((self.revision, delta));
+    }
+    /// This map's membership changes since `last_revision`, one of its own
+    /// earlier `membership_revision`s, or `None` when they can no longer be
+    /// answered: the consumer's revision predates what the ring kept, the map
+    /// was cleared since (a reset rebuilds everything), or the revision is not
+    /// this map's, which its own revisions give away: every one of them in the
+    /// answered range is the opening revision or a change the ring still
+    /// holds, so a revision another map took in between is refused, not
+    /// replayed.
+    pub fn deltas_since(
+        &self,
+        last_revision: u64,
+    ) -> Option<impl Iterator<Item = (u64, ChunkMembershipDelta)> + '_> {
+        if last_revision == 0
+            || last_revision < self.min_valid_revision
+            || last_revision > self.revision
+            || self.recent_deltas.is_empty()
+        {
+            return None;
+        }
+        let pos = self
+            .recent_deltas
+            .partition_point(|(rev, _)| *rev <= last_revision);
+        // A revision this map never took: another map's, drawing on the same
+        // process-wide counter. Only the opening revision and the ones the
+        // ring still holds are this map's.
+        let is_own_revision = last_revision == self.min_valid_revision
+            || (pos > 0 && self.recent_deltas[pos - 1].0 == last_revision);
+        if !is_own_revision {
+            return None;
+        }
+        let slice = self.recent_deltas.range(pos..);
+        if slice
+            .clone()
+            .any(|(_, d)| *d == ChunkMembershipDelta::Reset)
+        {
+            return None;
+        }
+        Some(slice.copied())
+    }
    pub fn insert(&mut self, key: Key, chunk: Arc<Chunk>) -> Option<Arc<Chunk>> {
+        if chunk.fresh {
+            self.fresh.insert(key);
+        } else {
+            self.fresh.remove(&key);
+        }
        let previous = self.columns.insert(key, chunk);
        if previous.is_none() {
            self.revision = next_revision();
+            self.record_delta(ChunkMembershipDelta::Added(key));
        }
        previous
    }
    pub fn remove(&mut self, key: &Key) -> Option<Arc<Chunk>> {
+        self.fresh.remove(key);
        let previous = self.columns.remove(key);
        if previous.is_some() {
            self.revision = next_revision();
+            self.record_delta(ChunkMembershipDelta::Removed(*key));
        }
        previous
    }
    pub fn clear(&mut self) {
        if !self.columns.is_empty() {
            self.columns.clear();
+            self.fresh.clear();
            self.revision = next_revision();
+            self.recent_deltas.clear();
+            self.recent_deltas
+                .push_back((self.revision, ChunkMembershipDelta::Reset));
+            self.min_valid_revision = self.revision;
        }
    }
+    pub fn has_fresh(&self) -> bool {
+        !self.fresh.is_empty()
+    }
+    /// The fresh keys in the chunk map's own iteration order, so the spawns
+    /// they drive run in the order a scan of the columns gave.
+    pub fn fresh_keys_ordered(&self) -> Vec<Key> {
+        if self.fresh.is_empty() {
+            Vec::new()
+        } else if self.fresh.len() == 1 {
+            self.fresh.iter().copied().collect()
+        } else {
+            self.columns
+                .keys()
+                .filter(|k| self.fresh.contains(k))
+                .copied()
+                .collect()
+        }
+    }
+    pub fn remove_fresh(&mut self, key: &Key) {
+        self.fresh.remove(key);
+    }
    pub fn get_mut(&mut self, key: &Key) -> Option<&mut Arc<Chunk>> {
        self.columns.get_mut(key)
    }
@@ -125,4 +240,146 @@ mod tests {
        map = ChunkMap::default();
        assert_ne!(cleared, map.membership_revision());
    }
+
+    /// The deltas' kinds, checking the ring answers in revision order.
+    fn kinds(deltas: Vec<(u64, ChunkMembershipDelta)>) -> Vec<ChunkMembershipDelta> {
+        let mut last = 0;
+        for (rev, _) in &deltas {
+            assert!(*rev > last, "the ring answers in revision order");
+            last = *rev;
+        }
+        deltas.into_iter().map(|(_, d)| d).collect()
+    }
+
+    /// Revision numbers are process-wide: the ones another map takes in
+    /// between, and a payload-only rewrite that takes none at all, say nothing
+    /// about this map's keys.
+    #[test]
+    fn deltas_since_ignores_revisions_other_maps_take() {
+        let mut map = ChunkMap::default();
+        let mut other = ChunkMap::default();
+        let chunk = Arc::new(Chunk::empty(0, 0));
+        map.insert((0, 0), chunk.clone());
+        let seen = map.membership_revision();
+        for key in [(1, 0), (2, 0), (3, 0)] {
+            other.insert(key, chunk.clone());
+        }
+        map.insert((0, 0), Arc::new(Chunk::empty(0, 0))); // Payload only.
+        map.insert((4, 0), chunk.clone());
+        map.remove(&(0, 0));
+        assert_eq!(
+            kinds(map.deltas_since(seen).unwrap().collect()),
+            [
+                ChunkMembershipDelta::Added((4, 0)),
+                ChunkMembershipDelta::Removed((0, 0)),
+            ]
+        );
+        // The consumer's own revision answers, with nothing new since.
+        assert!(
+            map.deltas_since(map.membership_revision())
+                .unwrap()
+                .next()
+                .is_none()
+        );
+        // A revision another map took in between: refused, not replayed.
+        assert!(map.deltas_since(other.membership_revision()).is_none());
+    }
+
+    /// A map built ahead of the live one, its revisions interleaved with it,
+    /// answering for a revision it never took: refused, so the consumer
+    /// rebuilds rather than replay another map's changes.
+    #[test]
+    fn deltas_since_none_for_interleaved_revision_from_another_map() {
+        let mut map = ChunkMap::default();
+        let mut other = ChunkMap::default();
+        let chunk = Arc::new(Chunk::empty(0, 0));
+        map.insert((0, 0), chunk.clone());
+        let seen = map.membership_revision();
+        other.insert((1, 0), chunk.clone());
+        let foreign = other.membership_revision();
+        map.insert((2, 0), chunk.clone());
+        assert!(map.deltas_since(foreign).is_none());
+        assert_eq!(
+            kinds(map.deltas_since(seen).unwrap().collect()),
+            [ChunkMembershipDelta::Added((2, 0))]
+        );
+    }
+
+    /// The ring answers for the changes it kept, and only those.
+    #[test]
+    fn deltas_since_none_for_a_revision_the_ring_dropped() {
+        let mut map = ChunkMap::default();
+        let chunk = Arc::new(Chunk::empty(0, 0));
+        let created = map.membership_revision();
+        let mut revisions = Vec::new();
+        let changes = MAX_RECENT_DELTAS as i32 + 1;
+        for i in 0..changes {
+            map.insert((i, 0), chunk.clone());
+            revisions.push(map.membership_revision());
+        }
+        let (first, kept) = revisions.split_first().unwrap();
+        // The oldest change fell out with the consumer's revision: rebuild.
+        assert!(map.deltas_since(created).is_none());
+        assert_eq!(map.deltas_since(*first).unwrap().count(), kept.len());
+    }
+
+    /// A reset rebuilds whatever the consumer last saw, and the ring answers
+    /// for what follows it.
+    #[test]
+    fn deltas_since_none_across_a_clear() {
+        let mut map = ChunkMap::default();
+        let chunk = Arc::new(Chunk::empty(0, 0));
+        map.insert((0, 0), chunk.clone());
+        let before = map.membership_revision();
+        map.clear();
+        assert!(map.deltas_since(before).is_none());
+        let cleared = map.membership_revision();
+        map.insert((1, 0), chunk);
+        assert_eq!(
+            kinds(map.deltas_since(cleared).unwrap().collect()),
+            [ChunkMembershipDelta::Added((1, 0))]
+        );
+    }
+
+    #[test]
+    fn fresh_chunks_tracking() {
+        let mut map = ChunkMap::default();
+        assert!(!map.has_fresh());
+        let mut chunk = Chunk::empty(1, 2);
+        chunk.fresh = true;
+        map.insert((1, 2), Arc::new(chunk));
+        assert!(map.has_fresh());
+        assert_eq!(map.fresh_keys_ordered(), vec![(1, 2)]);
+
+        map.remove_fresh(&(1, 2));
+        assert!(!map.has_fresh());
+
+        let mut chunk2 = Chunk::empty(3, 4);
+        chunk2.fresh = true;
+        map.insert((3, 4), Arc::new(chunk2));
+        assert!(map.has_fresh());
+
+        map.remove(&(3, 4));
+        assert!(!map.has_fresh());
+    }
+
+    #[test]
+    fn fresh_keys_ordered_matches_chunk_map_iteration_order() {
+        let mut map = ChunkMap::default();
+        let keys = [(-5, 10), (12, -3), (0, 0), (7, 8), (-1, -1), (4, 4)];
+        for (i, &key) in keys.iter().enumerate() {
+            let mut chunk = Chunk::empty(key.0, key.1);
+            chunk.fresh = i % 2 == 0;
+            map.insert(key, Arc::new(chunk));
+        }
+
+        let ordered = map.fresh_keys_ordered();
+        let expected: Vec<Key> = map
+            .keys()
+            .copied()
+            .filter(|k| map.fresh.contains(k))
+            .collect();
+        assert_eq!(ordered, expected);
+        assert_eq!(ordered.len(), 3);
+    }
 }
@@ -169,11 +169,13 @@ impl Mesh {
            let x0 = dx as f32 * 12.0;
            let z0 = dz as f32 * 12.0;
            let (x1, z1, y0, y1) = (x0 + 12.0, z0 + 12.0, 0.0, 4.0);
-            let mut quad = |p: [[f32; 3]; 4], shade: u32| {
+            // The face's normal is for shader packs (`gl_Normal`); the game's clouds shade by
+            // `shade`.
+            let mut quad = |p: [[f32; 3]; 4], shade: u32, normal: [i8; 4]| {
                for v in p {
                    // Overlay 4: clouds (unlit, faded by the cloud fog end).
                    self.vertices.push(crate::mesher::Vertex {
-                        normal: [0; 4],
+                        normal,
                        pos: v,
                        uv,
                        layer: 4,
@@ -186,17 +188,41 @@ impl Mesh {
            };
            if input.fast {
                for p in flat_cell(x0, z0, 0.0) {
-                    quad(p, 0);
+                    quad(p, 0, [0; 4]);
                }
                continue;
            }
            let quads = [
-                ([[x1, y0, z0], [x1, y0, z1], [x0, y0, z1], [x0, y0, z0]], 1),
-                ([[x0, y1, z0], [x0, y1, z1], [x1, y1, z1], [x1, y1, z0]], 0),
-                ([[x0, y0, z0], [x0, y1, z0], [x1, y1, z0], [x1, y0, z0]], 2),
-                ([[x1, y0, z1], [x1, y1, z1], [x0, y1, z1], [x0, y0, z1]], 2),
-                ([[x0, y0, z1], [x0, y1, z1], [x0, y1, z0], [x0, y0, z0]], 3),
-                ([[x1, y0, z0], [x1, y1, z0], [x1, y1, z1], [x1, y0, z1]], 3),
+                (
+                    [[x1, y0, z0], [x1, y0, z1], [x0, y0, z1], [x0, y0, z0]],
+                    1,
+                    [0, -127, 0, 0],
+                ),
+                (
+                    [[x0, y1, z0], [x0, y1, z1], [x1, y1, z1], [x1, y1, z0]],
+                    0,
+                    [0, 127, 0, 0],
+                ),
+                (
+                    [[x0, y0, z0], [x0, y1, z0], [x1, y1, z0], [x1, y0, z0]],
+                    2,
+                    [0, 0, -127, 0],
+                ),
+                (
+                    [[x1, y0, z1], [x1, y1, z1], [x0, y1, z1], [x0, y0, z1]],
+                    2,
+                    [0, 0, 127, 0],
+                ),
+                (
+                    [[x0, y0, z1], [x0, y1, z1], [x0, y1, z0], [x0, y0, z0]],
+                    3,
+                    [-127, 0, 0, 0],
+                ),
+                (
+                    [[x1, y0, z0], [x1, y1, z0], [x1, y1, z1], [x1, y0, z1]],
+                    3,
+                    [127, 0, 0, 0],
+                ),
            ];
            let mask = face_mask(
                dx as i32,
@@ -210,8 +236,12 @@ impl Mesh {
                ],
            );
            for (direction, inside) in faces(mask) {
-                let (p, shade) = quads[usize::from(direction)];
-                quad(if inside { [p[3], p[2], p[1], p[0]] } else { p }, shade);
+                let (p, shade, n) = quads[usize::from(direction)];
+                if inside {
+                    quad([p[3], p[2], p[1], p[0]], shade, n.map(|c| -c));
+                } else {
+                    quad(p, shade, n);
+                }
            }
        }
        self.key = Some(key);
@@ -343,8 +343,15 @@ impl EntityMovementWorld for SceneCollisions<'_, '_> {
 }
 impl DynamicSupportWorld for SceneCollisions<'_, '_> {
    type Error = io::Error;
-    fn shulker_is_closed(&mut self, _: [i32; 3]) -> io::Result<Option<bool>> {
-        Ok(None)
+    /// `ShulkerBoxBlockEntity.isClosed`: whether the lid is still shut. A
+    /// closed box collides as its plain block (`ShulkerBoxBlock.getShape`
+    /// asks the block entity, which has grown once the lid starts to open).
+    fn shulker_is_closed(&mut self, p: [i32; 3]) -> io::Result<Option<bool>> {
+        Ok(self
+            .world
+            .shulkers
+            .get(&p)
+            .map(|s| s.status == crate::block_entity_anim::ShulkerStatus::Closed))
    }
    /// `MovingPistonBlock.getCollisionShape`: the block entity's moving shape
    /// (`PistonMovingBlockEntity.getCollisionShape`), outside any push.
@@ -373,11 +380,17 @@ impl PistonCollisionWorld for SceneCollisions<'_, '_> {
    }
 }
 impl DynamicCollisionWorld for SceneCollisions<'_, '_> {
+    /// `ShulkerBoxBlockEntity.getBoundingBox`: the box's collision shape
+    /// (`getShape`) is the free shape grown by the lid's progress, which is
+    /// what lets an entity sink into an opening box. None: no such box here.
    fn shulker_collision_state(
        &mut self,
-        _: [i32; 3],
+        p: [i32; 3],
    ) -> io::Result<Option<ShulkerCollisionState>> {
-        Ok(None)
+        Ok(self.world.shulkers.get(&p).map(|s| ShulkerCollisionState {
+            previous_progress: s.progress_old,
+            progress: s.progress,
+        }))
    }
 }
 impl LiquidCollisionWorld for SceneCollisions<'_, '_> {
@@ -497,6 +510,8 @@ impl EntityMovementWorld for LookupCollisions<'_, '_> {
 }
 impl DynamicSupportWorld for LookupCollisions<'_, '_> {
    type Error = io::Error;
+    /// No block-entity data: a lookup world has no shulker box to ask, so the
+    /// box collides as a shut one (`VoxelShape::block()`).
    fn shulker_is_closed(&mut self, _: [i32; 3]) -> io::Result<Option<bool>> {
        Ok(None)
    }
@@ -505,6 +520,8 @@ impl DynamicSupportWorld for LookupCollisions<'_, '_> {
    }
 }
 impl DynamicCollisionWorld for LookupCollisions<'_, '_> {
+    /// No block-entity data: the block table's own shape stands in for the lid
+    /// (`ShulkerBoxBlockEntity.getBoundingBox` needs a block entity).
    fn shulker_collision_state(
        &mut self,
        _: [i32; 3],
@@ -611,3 +628,140 @@ mod border_movement_tests {
        );
    }
 }
+
+#[cfg(test)]
+mod shulker_collision_tests {
+    use super::*;
+    use crate::block_entity_anim::{Shulker, ShulkerStatus, progress_delta_aabb};
+    use horizon_core::geometry::{Aabb, Axis, Direction, Vec3, VoxelShape};
+
+    /// A shulker box facing up at progress 0.0 (closed): collision is a 1x1x1 block.
+    #[test]
+    fn shulker_closed_collision_is_full_block() {
+        let shulker = Shulker {
+            status: ShulkerStatus::Closed,
+            progress: 0.0,
+            progress_old: 0.0,
+            ..Shulker::default()
+        };
+
+        let state = ShulkerCollisionState {
+            previous_progress: shulker.progress_old,
+            progress: shulker.progress,
+        };
+        let aabb = state.bounding_box(Direction::Up);
+
+        // Closed box: height 1.0
+        assert!((aabb.min(Axis::Y) - 0.0).abs() < 1.0e-9);
+        assert!((aabb.max(Axis::Y) - 1.0).abs() < 1.0e-9);
+        // Full horizontal extent
+        assert!((aabb.min(Axis::X) - 0.0).abs() < 1.0e-9);
+        assert!((aabb.max(Axis::X) - 1.0).abs() < 1.0e-9);
+    }
+
+    /// A shulker box facing up at progress 1.0 (fully open): collision is 1.5 tall.
+    #[test]
+    fn shulker_open_collision_grows_upward() {
+        let shulker = Shulker {
+            status: ShulkerStatus::Opened,
+            progress: 1.0,
+            progress_old: 1.0,
+            ..Shulker::default()
+        };
+
+        let state = ShulkerCollisionState {
+            previous_progress: shulker.progress_old,
+            progress: shulker.progress,
+        };
+        let aabb = state.bounding_box(Direction::Up);
+
+        // Fully open: height 1.5 (lid extends 0.5 above the block)
+        assert!((aabb.min(Axis::Y) - 0.0).abs() < 1.0e-9);
+        assert!((aabb.max(Axis::Y) - 1.5).abs() < 1.0e-9);
+    }
+
+    /// A shulker box halfway open: collision height is 1.25.
+    #[test]
+    fn shulker_half_open_collision_height() {
+        let shulker = Shulker {
+            status: ShulkerStatus::Opening,
+            progress: 0.5,
+            progress_old: 0.5,
+            ..Shulker::default()
+        };
+
+        let state = ShulkerCollisionState {
+            previous_progress: shulker.progress_old,
+            progress: shulker.progress,
+        };
+        let aabb = state.bounding_box(Direction::Up);
+
+        // Half open: height 1.25
+        assert!((aabb.min(Axis::Y) - 0.0).abs() < 1.0e-9);
+        assert!((aabb.max(Axis::Y) - 1.25).abs() < 1.0e-9);
+    }
+
+    /// Vanilla clip quirk: an entity whose feet are *inside* the grown lid box
+    /// moving DOWN is not stopped by the box (collision only triggers when
+    /// approaching from outside). An entity ABOVE the box moving DOWN is stopped.
+    #[test]
+    fn shulker_grown_box_allows_clip_when_inside() {
+        // Box at progress 1.0: spans y=0..1.5
+        let shulker = Shulker {
+            status: ShulkerStatus::Opened,
+            progress: 1.0,
+            progress_old: 1.0,
+            ..Shulker::default()
+        };
+        let state = ShulkerCollisionState {
+            previous_progress: shulker.progress_old,
+            progress: shulker.progress,
+        };
+        let aabb = state.bounding_box(Direction::Up);
+        let box_shape = VoxelShape::from_box(aabb).expect("shulker box is a valid shape");
+
+        // Entity box whose feet are at y=0.5 (inside the grown box), height 1.8
+        let entity = Aabb::new(Vec3::new(0.2, 0.5, 0.2), Vec3::new(0.8, 2.3, 0.8));
+
+        // Moving DOWN from inside the box: collide() should NOT stop it
+        // (the entity is already intersecting the box, so the downward movement
+        // sees no face to hit from above).
+        let down = -0.1;
+        let moved_down = box_shape.collide(Axis::Y, entity, down);
+        assert!(
+            (moved_down - down).abs() < 1.0e-9,
+            "entity inside grown box should fall through (clip): moved_down={moved_down}, expected={down}"
+        );
+
+        // Entity box whose feet are at y=1.6 (just ABOVE the grown box)
+        let entity_above = Aabb::new(Vec3::new(0.2, 1.6, 0.2), Vec3::new(0.8, 3.4, 0.8));
+
+        // Moving DOWN from above: collide() SHOULD stop it at y=1.5
+        let moved_down_above = box_shape.collide(Axis::Y, entity_above, -0.2);
+        // The box's top is at y=1.5, entity bottom at 1.6, so max down is -0.1
+        assert!(
+            (moved_down_above - (-0.1)).abs() < 1.0e-9,
+            "entity above grown box should be stopped: moved_down_above={moved_down_above}, expected=-0.1"
+        );
+    }
+
+    /// An entity standing on the lid (y=1.0 when closed, y=1.5 when open)
+    /// and pushed up by the lid: the lid's swept AABB pushes it along the facing.
+    /// This is tested at the integration level via `push_shulker_entities`;
+    /// here we only verify the swept box geometry matches vanilla's
+    /// `Shulker.getProgressDeltaAabb`.
+    #[test]
+    fn shulker_swept_box_matches_vanilla_delta() {
+        // From closed (0.0) to progress 0.5: the lid sweeps from y=0..1 (closed box)
+        // to y=0..1.5 (half open), so the swept volume in world coords at position
+        // [0.5, 0.0, 0.5] (bottom center of block at y=0) is y=1.0..1.5.
+        let delta = progress_delta_aabb(1.0, Direction::Up as u8, 0.0, 0.5, [0.5, 0.0, 0.5]);
+        assert!((delta[1] - 1.0).abs() < 1.0e-9); // minY
+        assert!((delta[4] - 1.5).abs() < 1.0e-9); // maxY
+
+        // From progress 0.5 to 1.0: swept y=1.5..2.0 in world coords
+        let delta2 = progress_delta_aabb(1.0, Direction::Up as u8, 0.5, 1.0, [0.5, 0.0, 0.5]);
+        assert!((delta2[1] - 1.5).abs() < 1.0e-9);
+        assert!((delta2[4] - 2.0).abs() < 1.0e-9);
+    }
+}
@@ -4,7 +4,7 @@
 pub use crate::chunk::block_entity::{
    Banner, Beacon, BlockEntity, Brushable, Campfire, ChiseledBookshelf, Crafter, CreakingHeart,
    EndGateway, Furnace, FurnaceKind, Jukebox, Lectern, MOD_MENUS, ModBlockEntity, ModContainer,
-    PotentSulfur, Shelf, Skull, SkullSkin,
+    ModFluidTanks, PotentSulfur, Shelf, Skull, SkullSkin,
 };
 use crate::items::ItemStack;
 use std::collections::HashMap;
@@ -82,6 +82,39 @@ pub fn double_chest_name(first: Option<&str>, second: Option<&str>) -> horizon_w
    display_name(first.or(second), "container.chestDouble")
 }

+/// `BaseContainerBlockEntity.sendChestLockedNotifications`: the action bar
+/// message of a container that refuses to open, `container.isLocked` naming it
+/// by its display name.
+pub fn locked_message(title: &horizon_world::nbt::Tag) -> horizon_world::nbt::Tag {
+    use horizon_world::nbt::Tag;
+    Tag::compound([
+        ("translate", Tag::String("container.isLocked".into())),
+        ("with", Tag::List(vec![title.clone()])),
+    ])
+}
+
+/// The menu a container vehicle's `createMenu` builds (`ContainerEntity`):
+/// `AbstractChestBoat.createMenu` and `MinecartChest.createMenu` are
+/// `ChestMenu.threeRows` (a 9x3 menu), `MinecartHopper.createMenu` is a
+/// `HopperMenu` (five slots). `None` for any other entity type.
+pub fn vehicle_menu(entity_type: &str) -> Option<(&'static str, usize)> {
+    match entity_type {
+        "minecraft:chest_minecart" => Some(("minecraft:generic_9x3", 27)),
+        "minecraft:hopper_minecart" => Some(("minecraft:hopper", HOPPER_SLOTS)),
+        n if n.ends_with("_chest_boat") || n.ends_with("_chest_raft") => {
+            Some(("minecraft:generic_9x3", 27))
+        }
+        _ => None,
+    }
+}
+
+/// `MenuProvider.getDisplayName` for a container vehicle: `Entity.getDisplayName`
+/// is its custom name, else `getName`, the entity type's name key. Horizon's
+/// vehicles keep no custom name, so this is the type's name key.
+pub fn vehicle_menu_name(entity_type: &str) -> String {
+    format!("entity.{}", entity_type.replacen(':', ".", 1))
+}
+
 impl Campfire {
    /// `placeFood`'s slot: the first empty one, given the item's
    /// `campfire_cooking` time; it takes one item of `held`.
@@ -388,7 +421,7 @@ impl BlockEntity {
            Self::Furnace(f) => f.items.iter().flatten().cloned().collect(),
            Self::Brewing(b) => b.items.iter().flatten().cloned().collect(),
            Self::Sign(_) => Vec::new(),
-            Self::Jukebox(j) => j.record.iter().cloned().collect(),
+            Self::Jukebox(j) => j.items.iter().flatten().cloned().collect(),
            Self::Beacon(_)
            | Self::CreakingHeart(_)
            | Self::Spawner(_)
@@ -421,7 +454,6 @@ impl BlockEntity {
            Self::Furnace(f) => &f.items,
            Self::Brewing(b) => &b.items,
            Self::Sign(_)
-            | Self::Jukebox(_)
            | Self::Beacon(_)
            | Self::Lectern(_)
            | Self::Sculk(_)
@@ -435,6 +467,7 @@ impl BlockEntity {
            | Self::TestInstanceBlock(_)
            | Self::DaylightDetector
            | Self::Brushable(_) => &[],
+            Self::Jukebox(j) => &j.items,
            Self::Crafter(c) => &c.items,
            Self::ChiseledBookshelf(b) => &b.items,
            Self::Shelf(b) => &b.items,
@@ -455,7 +488,6 @@ impl BlockEntity {
            Self::Furnace(f) => &mut f.items,
            Self::Brewing(b) => &mut b.items,
            Self::Sign(_)
-            | Self::Jukebox(_)
            | Self::Beacon(_)
            | Self::Lectern(_)
            | Self::Sculk(_)
@@ -469,6 +501,7 @@ impl BlockEntity {
            | Self::TestInstanceBlock(_)
            | Self::DaylightDetector
            | Self::Brushable(_) => &mut [],
+            Self::Jukebox(j) => &mut j.items,
            Self::Crafter(c) => &mut c.items,
            Self::ChiseledBookshelf(b) => &mut b.items,
            Self::Shelf(b) => &mut b.items,
@@ -612,6 +645,26 @@ mod tests {
        assert_eq!(fifth.count, 1);
    }

+    /// `JukeboxBlockEntity`'s single slot is a `Container` slot, so a hopper
+    /// (`HopperBlockEntity.getContainerAt`) can reach the disc in it.
+    #[test]
+    fn a_jukebox_offers_its_record_as_its_one_container_slot() {
+        let mut entity = BlockEntity::Jukebox(Jukebox::default());
+        assert_eq!(entity.slots().len(), 1);
+        assert!(entity.slots()[0].is_none(), "empty until a disc lands");
+        let disc = ItemStack::new("minecraft:cat", 1);
+        entity.slots_mut()[0] = Some(disc.clone());
+        let slots = entity.slots();
+        assert_eq!(slots[0].as_ref().map(|s| &*s.item), Some("minecraft:cat"));
+        match &entity {
+            BlockEntity::Jukebox(j) => {
+                assert_eq!(j.record().map(|s| &*s.item), Some("minecraft:cat"));
+            }
+            _ => panic!("a jukebox"),
+        }
+        assert_eq!(entity.contents().len(), 1);
+    }
+
    /// A whole amount pays itself without a draw; a fraction is a chance of one more.
    #[test]
    fn create_experience_rounds_the_fraction_by_chance() {
@@ -23,7 +23,7 @@ enum Source {
 }
 impl DataPack {
    /// Every file path under `prefix` (relative to the pack root).
-    fn list(&self, prefix: &str) -> Vec<String> {
+    pub fn list(&self, prefix: &str) -> Vec<String> {
        match &self.source {
            Source::Zip(z) => z
                .names()
@@ -58,12 +58,13 @@ impl DataPack {
        }
        out
    }
-    fn read(&self, path: &str) -> Option<Vec<u8>> {
+    pub fn read(&self, path: &str) -> Option<Vec<u8>> {
        match &self.source {
            Source::Zip(z) => z.read(path).ok(),
            Source::Dir(root) => std::fs::read(root.join(path)).ok(),
        }
    }
+
    /// The `description` of `pack.mcmeta`, as text.
    pub fn description(&self) -> String {
        let Some(bytes) = self.read("pack.mcmeta") else {
@@ -75,6 +76,24 @@ impl DataPack {
            other => other["text"].as_str().unwrap_or_default().to_owned(),
        }
    }
+    /// The `features.enabled` flag ids of `pack.mcmeta`
+    /// (`FeatureFlagsMetadataSection`): the flags the pack asks to turn on.
+    pub fn features(&self) -> Vec<String> {
+        self.mcmeta()["features"]["enabled"]
+            .as_array()
+            .map(|a| {
+                a.iter()
+                    .filter_map(|f| f.as_str().map(str::to_owned))
+                    .collect()
+            })
+            .unwrap_or_default()
+    }
+    /// The `pack.mcmeta` as JSON, empty when it is missing or unreadable.
+    fn mcmeta(&self) -> serde_json::Value {
+        self.read("pack.mcmeta")
+            .and_then(|b| serde_json::from_slice(&b).ok())
+            .unwrap_or_default()
+    }
 }
 fn walk(root: &Path, dir: &Path, out: &mut Vec<String>) {
    let Ok(entries) = std::fs::read_dir(dir) else {
@@ -127,14 +146,43 @@ pub fn discover(world: &Path) -> Vec<DataPack> {
    packs.sort_by(|a, b| a.id.cmp(&b.id));
    packs
 }
+/// The resources root's built-in feature packs (`ServerPacksSource`
+/// scanning the game's `data/minecraft/datapacks`): every folder with a
+/// `pack.mcmeta`, a feature pack (`PackSource.FEATURE`). Off until a world
+/// selects them.
+pub fn feature_packs(resources: &Path) -> Vec<DataPack> {
+    let Ok(entries) = std::fs::read_dir(resources.join("data").join("minecraft").join("datapacks"))
+    else {
+        return Vec::new();
+    };
+    let mut packs = Vec::new();
+    for e in entries.flatten() {
+        let path = e.path();
+        if path.join("pack.mcmeta").exists() {
+            packs.push(DataPack {
+                id: e.file_name().to_string_lossy().into_owned(),
+                source: Source::Dir(path),
+            });
+        }
+    }
+    packs.sort_by(|a, b| a.id.cmp(&b.id));
+    packs
+}
+/// The packs of `<world>/datapacks` plus the resources root's feature packs:
+/// the world's whole repository, as `PackRepository.reload` sees it.
+pub fn discover_with_features(world_root: &Path, resources: &Path) -> Vec<DataPack> {
+    let mut packs = discover(world_root);
+    packs.extend(feature_packs(resources));
+    packs
+}

 // ---- Create World ------------------------------------------------------------

 /// Create World's Data Packs screen (`PackSelectionScreen` on vanilla's
-/// `mcworld-` folder): the folder's packs (`PackSource.WORLD`) and the
-/// built-in one (`resources` holds its `pack.png`), which can be unselected
-/// and stays at the bottom. Horizon has no experiments, so their feature
-/// packs are not offered.
+/// `mcworld-` folder): the folder's packs (`PackSource.WORLD`), the
+/// built-in one (`resources` holds its `pack.png`), and the feature packs
+/// of `resources` (`PackSource.FEATURE`), available at the bottom and off
+/// until picked — the Experiments.
 pub fn screen_packs(dir: &Path, resources: &Path) -> Vec<crate::pack_screen::PackInfo> {
    use crate::{
        pack_screen::{Compat, PackInfo, Source, load_icon},
@@ -172,6 +220,23 @@ pub fn screen_packs(dir: &Path, resources: &Path) -> Vec<crate::pack_screen::Pac
        position: Position::Bottom,
        fixed: false,
    });
+    for p in feature_packs(resources) {
+        let meta = p.mcmeta();
+        let (description, description_style) =
+            crate::packs::component_root(&meta["pack"]["description"]);
+        infos.push(PackInfo {
+            icon: None,
+            id: p.id.clone(),
+            title: Text::translate(&format!("dataPack.{}.name", p.id), &[]),
+            description,
+            description_style,
+            source: Source::Feature,
+            compat: crate::packs::compatibility_for(&meta, format),
+            required: false,
+            position: Position::Bottom,
+            fixed: false,
+        });
+    }
    infos
 }
 /// A new empty folder for Create World's packs
@@ -185,6 +250,59 @@ pub fn temp_folder() -> std::io::Result<PathBuf> {
    std::fs::create_dir_all(&dir)?;
    Ok(dir)
 }
+/// `PackSelectionScreen.onFilesDrop`'s `PackDetector`: a zip is a pack; a
+/// folder is one when it holds a `pack.mcmeta`, or exactly one folder that
+/// does (a folder zipped by the system, which adds a wrapper). Copied into
+/// `dir`; false when `path` is no pack.
+pub fn copy_pack(path: &Path, dir: &Path) -> bool {
+    fn copy_dir(from: &Path, at: &Path) {
+        let _ = std::fs::create_dir_all(at);
+        for entry in std::fs::read_dir(from).into_iter().flatten().flatten() {
+            let path = entry.path();
+            let to = at.join(entry.file_name());
+            if path.is_dir() {
+                copy_dir(&path, &to);
+            } else {
+                let _ = std::fs::copy(&path, &to);
+            }
+        }
+    }
+    let name = || {
+        path.file_name()
+            .map(|n| n.to_string_lossy().into_owned())
+            .unwrap_or_default()
+    };
+    if path.is_file() {
+        return path
+            .extension()
+            .is_some_and(|e| e.eq_ignore_ascii_case("zip"))
+            && {
+                let _ = std::fs::create_dir_all(dir);
+                std::fs::copy(path, dir.join(name())).is_ok()
+            };
+    }
+    if !path.is_dir() {
+        return false;
+    }
+    if path.join("pack.mcmeta").is_file() {
+        copy_dir(path, &dir.join(name()));
+        return true;
+    }
+    let own: Vec<PathBuf> = std::fs::read_dir(path)
+        .into_iter()
+        .flatten()
+        .flatten()
+        .map(|e| e.path())
+        .filter(|p| p.is_dir() && p.join("pack.mcmeta").is_file())
+        .collect();
+    match own.as_slice() {
+        [one] => {
+            copy_dir(one, &dir.join(one.file_name().unwrap_or_default()));
+            true
+        }
+        _ => false,
+    }
+}
 /// What's in a folder of packs, to notice packs added or removed while the
 /// screen shows it (`PackSelectionScreen.Watcher`).
 pub fn folder_stamp(dir: &Path) -> Vec<(String, Option<std::time::SystemTime>)> {
@@ -230,7 +348,11 @@ pub fn install(dir: &Path, world: &Path, selected: &[String]) -> Result<(), Stri
 /// The built-in pack is selected unless the world turned it off.
 pub fn for_recreate(world: &Path) -> (Option<PathBuf>, Vec<String>) {
    let packs = discover(world);
-    let mut selected = enabled_ids(world, &packs);
+    // No flags here: the recreated world keeps the original's
+    // `enabled_features`, and the flag-aware load re-adds the feature packs
+    // it asks for (`for_recreate`'s selection only seeds the new world's
+    // `datapacks.json`).
+    let mut selected = enabled_ids(world, &packs, &[]);
    let vanilla_off = std::fs::read(world.join("datapacks.json"))
        .ok()
        .and_then(|b| serde_json::from_slice::<serde_json::Value>(&b).ok())
@@ -453,7 +575,7 @@ pub struct DataStore {
    /// `item_modifier` files, for `/item modify`.
    pub item_modifiers: BTreeMap<String, serde_json::Value>,
    /// The content tables' raw files from the packs after the built-in one:
-    /// `recipe/`, `loot_table/`, `advancement/` and `tags/…/` files, by
+    /// `recipe/`, `loot_table/`, `advancement/`, `dialog/` and `tags/…/` files, by
    /// `<kind-dir>/<ns>:<path>`, each id's files in pack order. The tables
    /// merge them over what they read from the resource root.
    pub files: BTreeMap<String, Vec<Vec<u8>>>,
@@ -461,17 +583,20 @@ pub struct DataStore {
    pub errors: Vec<(String, String)>,
 }
 /// `<kind-dir>/<ns>:<path>` for a pack file the content tables read:
-/// `recipe/`, `loot_table/`, `advancement/` or `tags/<sub>/`, where the id
-/// keeps the sub path so a nested tag kind stays addressable.
+/// `recipe/`, `loot_table/`, `advancement/`, `trade_set/`,
+/// `villager_trade/`, `dialog/` or `tags/<sub>/`, where the id keeps the sub
+/// path so a nested tag kind stays addressable.
 fn content_id(file: &str) -> Option<String> {
    let rest = file.strip_prefix("data/")?;
    let (ns, rest) = rest.split_once('/')?;
    let (kind, rest) = rest.split_once('/')?;
    let kind = match kind {
-        "recipe" | "loot_table" | "advancement" => kind,
+        "recipe" | "loot_table" | "advancement" | "trade_set" | "villager_trade" | "dialog" => kind,
+        // A tag id is `{ns}:{path-under-tags}` (`tags/worldgen/biome/
+        // test:sub/mytag`), the whole path after the namespace, so nested
+        // registries keep their directory (`TagLoader`'s id shape).
        "tags" => {
-            let (sub, name) = rest.rsplit_once('/')?;
-            return Some(format!("tags/{sub}/{ns}:{}", name.strip_suffix(".json")?));
+            return Some(format!("tags/{ns}:{}", rest.strip_suffix(".json")?));
        }
        _ => return None,
    };
@@ -497,12 +622,15 @@ impl DataStore {
            let builtin = pack.id == "vanilla";
            for f in pack.list_kinds(&[
                "advancement",
+                "dialog",
                "function",
                "item_modifier",
                "loot_table",
                "predicate",
                "recipe",
                "tags",
+                "trade_set",
+                "villager_trade",
            ]) {
                if !seen.insert(f.clone()) {
                    continue;
@@ -616,10 +744,25 @@ fn hash_normalize(s: &str) -> String {
    }
 }

+/// Whether every flag `pack` asks for (`Pack.getRequestedFeatures`) is among
+/// the world's `enabled_features`.
+fn features_enabled(pack: &DataPack, enabled_features: &[String]) -> bool {
+    pack.features()
+        .iter()
+        .all(|f| enabled_features.iter().any(|e| e == f))
+}
+
 /// The ids of `packs` (a world's, from `discover`) that are enabled, lowest
 /// priority first: those `<world>/datapacks.json` lists as enabled, in its
 /// order, then every pack it lists neither way, in name order.
-pub fn enabled_ids(world: &Path, packs: &[DataPack]) -> Vec<String> {
+///
+/// `enabled_features` are the world's feature flags
+/// (`WorldDataConfiguration.enabledFeatures`): a pack a pack file selected
+/// while asking for missing features comes off
+/// (`MinecraftServer.configurePackRepository`), and a feature pack whose
+/// features the world enables is forced on however the world's selection
+/// feels about it (`MinecraftServer.enableForcedFeaturePacks`).
+pub fn enabled_ids(world: &Path, packs: &[DataPack], enabled_features: &[String]) -> Vec<String> {
    let saved: Option<serde_json::Value> = std::fs::read(world.join("datapacks.json"))
        .ok()
        .and_then(|b| serde_json::from_slice(&b).ok());
@@ -638,9 +781,32 @@ pub fn enabled_ids(world: &Path, packs: &[DataPack]) -> Vec<String> {
    let mut enabled: Vec<String> = list("enabled")
        .into_iter()
        .filter(|id| packs.iter().any(|p| &p.id == id))
+        .filter(|id| {
+            packs
+                .iter()
+                .find(|p| &p.id == id)
+                .is_none_or(|p| features_enabled(p, enabled_features))
+        })
        .collect();
    for p in packs {
-        if !enabled.contains(&p.id) && !disabled.contains(&p.id) {
+        // A pack nobody mentions comes on (`PackRepository.reload` selects
+        // every new pack), but a feature pack stays off until the world
+        // enabled its flag (`PackSource.FEATURE` starts unselected).
+        if !enabled.contains(&p.id)
+            && !disabled.contains(&p.id)
+            && p.id.starts_with("file/")
+            && features_enabled(p, enabled_features)
+        {
+            enabled.push(p.id.clone());
+        }
+    }
+    for p in packs {
+        let feature_pack = !p.id.starts_with("file/") && p.id != "vanilla";
+        if feature_pack
+            && !p.features().is_empty()
+            && features_enabled(p, enabled_features)
+            && !enabled.contains(&p.id)
+        {
            enabled.push(p.id.clone());
        }
    }
@@ -751,7 +917,7 @@ mod tests {
        )
        .unwrap();
        let packs = discover(&dir);
-        let enabled = enabled_ids(&dir, &packs);
+        let enabled = enabled_ids(&dir, &packs, &[]);
        assert_eq!(enabled, ["file/b", "file/a"]);
        let enabled: Vec<&DataPack> = enabled
            .iter()
@@ -865,6 +1031,10 @@ mod tests {
            "data/mine/predicate/p.json",
            "{\"condition\":\"minecraft:random_chance\",\"chance\":1}",
        );
+        write(
+            "data/mine/dialog/config/points.json",
+            "{\"type\":\"minecraft:notice\",\"title\":\"Points\"}",
+        );
        let packs = discover(&dir);
        assert_eq!(packs.len(), 1);
        assert_eq!(packs[0].id, "file/mypack");
@@ -877,6 +1047,11 @@ mod tests {
            ["mine:a", "mine:sub/b"]
        );
        assert!(store.predicates.contains_key("mine:p"));
+        // Dialogs reach the synchronized registry through the content files.
+        assert_eq!(
+            store.files["dialog/mine:config/points"],
+            [b"{\"type\":\"minecraft:notice\",\"title\":\"Points\"}".to_vec()]
+        );
        let _ = std::fs::remove_dir_all(&dir);
    }

@@ -13,6 +13,37 @@ use std::collections::HashMap;

 /// Lights the shaders read: `Globals.dynamic_lights` in gfx.rs, terrain.wgsl and entity.wgsl.
 pub const MAX: usize = 16;
+/// Camera-relative position and radius; RGB intensity in a second vec4.
+pub type Colored = [[f32; 4]; 2];
+
+/// Nearest validated native visual lights; never enters gameplay lighting.
+pub fn select_colored(
+    sources: impl Iterator<Item = ([f64; 3], u32, f32, f32)>,
+    camera: DVec3,
+) -> Vec<Colored> {
+    let mut nearest: Vec<_> = sources.collect();
+    nearest.sort_by(|a, b| {
+        (DVec3::from(a.0) - camera)
+            .length_squared()
+            .total_cmp(&(DVec3::from(b.0) - camera).length_squared())
+    });
+    nearest
+        .into_iter()
+        .take(MAX)
+        .map(|(at, rgb, radius, intensity)| {
+            let at = (DVec3::from(at) - camera).as_vec3();
+            [
+                [at.x, at.y, at.z, radius],
+                [
+                    ((rgb >> 16) & 255) as f32 / 255.0,
+                    ((rgb >> 8) & 255) as f32 / 255.0,
+                    (rgb & 255) as f32 / 255.0,
+                    intensity,
+                ],
+            ]
+        })
+        .collect()
+}
 /// What an entity on fire gives off, as a lit campfire or fire block does.
 pub const BURNING: u8 = 15;
 /// Sources farther than this from the camera light nothing it can see well.
@@ -87,6 +118,17 @@ pub fn level_at(pos: [f32; 3], lights: &[[f32; 4]]) -> f32 {
 mod tests {
    use super::*;

+    #[test]
+    fn colored_sources_are_camera_relative_and_bounded() {
+        let lights = select_colored(
+            (0..20).map(|x| ([x as f64, 64.0, 0.0], 0xff8040, 5.0, 0.5)),
+            DVec3::new(2.0, 64.0, 0.0),
+        );
+        assert_eq!(lights.len(), MAX);
+        assert_eq!(lights[0][0][0], 0.0);
+        assert_eq!(lights[0][1], [1.0, 128.0 / 255.0, 64.0 / 255.0, 0.5]);
+    }
+
    #[test]
    fn nearest_sources_win() {
        let camera = DVec3::new(100.0, 64.0, 100.0);
@@ -235,10 +235,12 @@ impl PlayerEffects {
        i8::from(e.ambient) | i8::from(e.visible) << 1 | 4
    }
    /// `LivingEntity.tickEffects` (server part) with the omens' effect ticks:
-    /// `omen` answers `BadOmenMobEffect` (every tick) and `RaidOmenMobEffect`
-    /// (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.
+    /// `omen` answers `BadOmenMobEffect` (every tick), `RaidOmenMobEffect`
+    /// (on its last tick) and a content mod's effect (every tick, with the
+    /// tick count `shouldApplyEffectTickThisTick` takes); `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
@@ -247,7 +249,7 @@ impl PlayerEffects {
    /// ticked; the next tick refreshes Raid Omen and drops Bad Omen.
    pub fn tick_with(
        &mut self,
-        omen: &mut dyn FnMut(&EffectInstance) -> OmenTick,
+        omen: &mut dyn FnMut(&EffectInstance, i32) -> OmenTick,
        absorption_empty: bool,
    ) -> (Vec<EffectAction>, bool) {
        self.tick_count = self.tick_count.wrapping_add(1);
@@ -269,8 +271,9 @@ impl PlayerEffects {
                actions.push(a);
            }
            let answer = match e.id {
-                "bad_omen" => omen(e),
-                "raid_omen" if t == 1 => omen(e),
+                "bad_omen" => omen(e, t),
+                "raid_omen" if t == 1 => omen(e, t),
+                id if potions::is_mod_effect(id) => omen(e, t),
                "absorption" if absorption_empty => OmenTick::Remove,
                _ => OmenTick::Continue,
            };
@@ -508,7 +511,7 @@ mod tests {
        let mut fx = PlayerEffects::default();
        fx.add(EffectInstance::new("bad_omen", 100, 1));
        fx.add(EffectInstance::new("speed", 50, 0));
-        let mut convert = |e: &EffectInstance| match e.id {
+        let mut convert = |e: &EffectInstance, _: i32| match e.id {
            "bad_omen" => OmenTick::Add(EffectInstance::new("raid_omen", 600, e.amplifier)),
            _ => OmenTick::Continue,
        };
@@ -550,12 +553,39 @@ mod tests {
                .is_empty()
        );
    }
+    /// A content mod's effect answers each tick before it counts down (an
+    /// infinite one with the tick count), and goes at once on Remove.
+    #[test]
+    fn a_mod_effect_answers_before_it_counts_down() {
+        let mut fx = PlayerEffects::default();
+        fx.add(EffectInstance::new("ruby:glow", 3, 1));
+        fx.add(EffectInstance::new("ruby:bleed", -1, 0));
+        let mut seen = Vec::new();
+        let mut answer = |e: &EffectInstance, t: i32| {
+            seen.push((e.id, t));
+            match (e.id, t) {
+                ("ruby:glow", 2) => OmenTick::Remove,
+                _ => OmenTick::Continue,
+            }
+        };
+        fx.tick_with(&mut answer, false);
+        fx.tick_with(&mut answer, false);
+        let ticks = [
+            ("ruby:glow", 3),
+            ("ruby:bleed", 1),
+            ("ruby:glow", 2),
+            ("ruby:bleed", 2),
+        ];
+        assert_eq!(seen, ticks);
+        assert!(fx.get("ruby:glow").is_none());
+        assert_eq!(fx.get("ruby:bleed").unwrap().duration, -1);
+    }
    #[test]
    fn raid_omen_acts_on_its_last_tick() {
        let mut fx = PlayerEffects::default();
        fx.add(EffectInstance::new("raid_omen", 2, 0));
        let mut seen = Vec::new();
-        let mut watch = |e: &EffectInstance| {
+        let mut watch = |e: &EffectInstance, _: i32| {
            seen.push(e.duration);
            OmenTick::Remove
        };
@@ -22,6 +22,10 @@ struct Globals {
    outline_params: vec4<f32>,
    // Horizon Extras' dynamic lights: camera-relative position and level (dynamic_light.rs).
    dynamic_lights: array<vec4<f32>, 16>,
+    colored_lights: array<array<vec4<f32>, 2>, 16>,
+    colored_count: vec4<u32>,
+    emissive_layers: array<vec4<u32>, 32>,
+    emissive_count: vec4<u32>,
    sunrise_fan: array<vec4<f32>, 32>,
    filtering: vec4<f32>,
 }
@@ -90,6 +94,15 @@ fn dynamic_block_light(pos: vec3<f32>) -> f32 {
    }
    return level * 16.0;
 }
+fn native_colored_light(pos: vec3<f32>) -> vec3<f32> {
+    var rgb = vec3(0.0);
+    for (var i = 0u; i < min(globals.colored_count.x, 16u); i++) {
+        let at = globals.colored_lights[i][0];
+        let color = globals.colored_lights[i][1];
+        rgb += color.rgb * max(0.0, 1.0 - distance(pos, at.xyz) / at.w) * color.a;
+    }
+    return min(rgb, vec3(1.0));
+}
 fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
    overlay: u32, color: vec4<f32>, light: vec4<u32>, normal: vec4<f32>) -> Out {
    var out: Out;
@@ -103,6 +116,9 @@ fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
    let unlit = overlay == 2u || overlay == 4u || overlay == 6u || overlay == 9u || overlay == 10u
        || overlay == 11u || overlay == 12u;
    out.light_color = select(lm, vec4(1.0), unlit);
+    if globals.colored_count.x > 0u && !unlit {
+        out.light_color = vec4(min(out.light_color.rgb + native_colored_light(position), vec3(1.0)), out.light_color.a);
+    }
    // Overlay 6 (beacon beams): the light bytes carry the sprite's v range; 11 and 12
    // (cracks): the destroy stage sprite's origin.
    out.wrap = vec2(f32(light.x | (light.y << 8u)), f32(light.z | (light.w << 8u))) / 65535.0;
@@ -141,7 +157,9 @@ fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
@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(7) offset: vec3<f32>) -> Out {
-    return entity_vertex(offset + position, uv, overlay, color, light, normal);
+    var out = entity_vertex(offset + position, uv, overlay & 0xffffu, color, light, normal);
+    out.tier = (overlay >> 16u) & 0xffu;
+    return out;
 }
 struct CloudInfo {
    offset: vec4<f32>,
@@ -294,7 +312,10 @@ fn shadow_color(in: Out) -> vec4<f32> {
 // way terrain.wgsl marks a light source's, drawn again after the entities with
 // only alpha written, so its colour stays as blended.
@fragment fn fs_hdr_mark(in: Out) -> @location(0) vec4<f32> {
-    if in.tier == 0u || textureSample(atlas, atlas_sampler, in.uv).a < 0.1 { discard; }
+    // Beams wrap their v in the sprite as fs_entity does: sample where they draw.
+    var uv = in.uv;
+    if in.overlay == 6u { uv.y = in.wrap.x + fract(in.uv.y) * in.wrap.y; }
+    if in.tier == 0u || textureSample(atlas, atlas_sampler, uv).a < 0.1 { discard; }
    return vec4(0.0, 0.0, 0.0, 0.7 * f32(4u - min(in.tier, 4u)) / 4.0);
 }

@@ -72,6 +72,8 @@ pub(super) struct SpriteAnimator {
    size: u32,
    /// The layers the last `animate` rewrote, counted over all arrays.
    changed: Vec<u32>,
+    /// Whether each sprite layer has an animation.
+    is_animated: Vec<bool>,
 }

 impl SpriteAnimator {
@@ -147,6 +149,11 @@ impl SpriteAnimator {
                group,
            });
        }
+        let max_layer = animations.iter().map(|a| a.layer).max().unwrap_or(0);
+        let mut is_animated = vec![false; (max_layer + 1) as usize];
+        for a in animations {
+            is_animated[a.layer as usize] = true;
+        }
        let Some((pipeline, layout)) = pipeline else {
            let groups = keys
                .iter()
@@ -168,6 +175,7 @@ impl SpriteAnimator {
                },
                size,
                changed: Vec::new(),
+                is_animated,
            };
        };
        let frames: Vec<_> = frames
@@ -247,9 +255,23 @@ impl SpriteAnimator {
            writer: Writer::Gpu { jobs, pipeline },
            size,
            changed: Vec::new(),
+            is_animated,
        }
    }

+    /// Whether the sprite layer has an animation.
+    pub fn is_animated(&self, layer: u16) -> bool {
+        self.is_animated
+            .get(layer as usize)
+            .copied()
+            .unwrap_or(false)
+    }
+
+    /// Number of words needed to mark the animated layers visible this frame.
+    pub fn active_layer_words(&self) -> usize {
+        self.is_animated.len().div_ceil(u64::BITS as usize)
+    }
+
    /// Whether the jobs can run on the GPU: compute shaders writing a
    /// storage texture and reading two storage buffers (not OpenGL before
    /// 4.3).
@@ -269,14 +291,16 @@ impl SpriteAnimator {
    }

    /// Show every sprite's frame at `tick`, rewriting only the sprites whose
-    /// frame or mix changed (`SpriteContents.AnimationState.tick`).
+    /// frame or mix changed (`SpriteContents.AnimationState.tick`), skipping
+    /// sprites not present in `active` when provided.
    pub fn animate(
        &mut self,
        encoder: &mut wgpu::CommandEncoder,
        uploads: &mut Uploads,
        tick: u64,
+        active: Option<&[u64]>,
    ) {
-        if self.collect(tick) == 0 {
+        if self.collect(tick, active) == 0 {
            return;
        }
        let (jobs, pipeline) = match &self.writer {
@@ -336,10 +360,18 @@ impl SpriteAnimator {

    /// Queue a job for every sprite whose blend at `tick` differs from what
    /// its layer shows; the number of jobs.
-    fn collect(&mut self, tick: u64) -> usize {
+    fn collect(&mut self, tick: u64, active: Option<&[u64]>) -> usize {
        let mut count = 0;
        self.changed.clear();
        for sprite in &mut self.sprites {
+            if let Some(active) = active {
+                let layer = sprite.animation.layer as usize;
+                let word = layer / u64::BITS as usize;
+                let bit = 1_u64 << (layer % u64::BITS as usize);
+                if active.get(word).is_none_or(|active| active & bit == 0) {
+                    continue;
+                }
+            }
            let blend = sprite.animation.blend(tick);
            if sprite.shown == Some(blend) {
                continue;
@@ -827,7 +859,7 @@ mod tests {
        for tick in [0, 0, 1, 2, 3, 4, 7, 7, 12, 30] {
            let mut encoder = device.create_command_encoder(&Default::default());
            let shown: Vec<_> = animator.sprites.iter().map(|s| s.shown).collect();
-            animator.animate(&mut encoder, &mut uploads, tick);
+            animator.animate(&mut encoder, &mut uploads, tick, None);
            writes.push(
                animator
                    .sprites
@@ -864,4 +896,56 @@ mod tests {
        // its frame turns over (every 2 ticks, but 12 shows 7's frame).
        assert_eq!(writes, [3, 0, 2, 3, 2, 3, 3, 0, 2, 1]);
    }
+
+    #[test]
+    fn inactive_sprites_are_skipped_by_collect() {
+        let Some((device, _)) = device() else {
+            return;
+        };
+        let size = 16;
+        let clips = [
+            (1, 16, r#"{"frametime":1}"#),
+            (3, 16, r#"{"frametime":1}"#),
+            (5, 16, r#"{"frametime":1}"#),
+        ];
+        let mut mips = vec![Settings::default(); 6];
+        let animations: Vec<_> = clips
+            .iter()
+            .map(|&(layer, native, metadata)| {
+                mips[layer as usize] = settings(native, Strategy::Cutout);
+                let frames = (0..3)
+                    .map(|f| crate::sprites::resample(&frame(native, layer * 7 + f), native, size))
+                    .collect();
+                crate::sprites::test_frames(layer, frames, metadata)
+            })
+            .collect();
+        // Construct with CPU writer (empty textures is fine for collect testing)
+        let mut animator = SpriteAnimator::new(&device, &animations, size, &mips, &[], 2, false);
+        assert!(animator.is_animated(1));
+        assert!(!animator.is_animated(2));
+        assert!(animator.is_animated(3));
+        assert!(animator.is_animated(5));
+
+        // When active layer is [1], only sprite 1 is collected
+        let active = [1_u64 << 1];
+        let count = animator.collect(1, Some(&active));
+        assert_eq!(count, 1);
+        assert_eq!(animator.changed, vec![1]);
+
+        // When active is empty, 0 are collected
+        let count = animator.collect(2, Some(&[0]));
+        assert_eq!(count, 0);
+        assert!(animator.changed.is_empty());
+
+        // When active is [3, 5], both 3 and 5 are collected
+        let active = [1_u64 << 3 | 1_u64 << 5];
+        let count = animator.collect(3, Some(&active));
+        assert_eq!(count, 2);
+        assert_eq!(animator.changed, vec![3, 5]);
+
+        // When active is None, all out-of-date sprites update
+        let count = animator.collect(5, None);
+        assert_eq!(count, 3);
+        assert_eq!(animator.changed, vec![1, 3, 5]);
+    }
 }
@@ -76,8 +76,22 @@ struct Page {
    /// Capacity in vertices.
    capacity: u64,
    free: FreeList,
+    /// The buffer went to system memory (`Arena::create`'s fallback): meshes
+    /// are never moved into it, and it is the first to empty.
+    host: bool,
 }

+impl Page {
+    /// Vertices in the page's free ranges.
+    fn free_vertices(&self) -> u64 {
+        self.free.0.values().sum()
+    }
+}
+
+/// An arena with this many bytes in free ranges, at least half of its pages,
+/// has a page worth emptying (`Arena::sparsest`).
+const COMPACT_MIN_FREE: u64 = 128 << 20;
+
 /// Terrain vertices in pages of at most `page_limit` vertices (devices cap
 /// buffer sizes): a section's vertices sit in one page.
 pub struct Arena {
@@ -86,6 +100,8 @@ pub struct Arena {
    page_limit: u64,
    initial_capacity: u64,
    usage: wgpu::BufferUsages,
+    /// A page being emptied (`Arena::close`): nothing is placed in it.
+    closing: Option<u32>,
    /// A page had to go to system memory (logged once).
    spilled: bool,
    /// Tests: GPU-local pages fail as if video memory were full.
@@ -129,6 +145,7 @@ impl Arena {
            page_limit,
            initial_capacity: capacity,
            usage,
+            closing: None,
            spilled: false,
            #[cfg(test)]
            video_memory_full: false,
@@ -138,7 +155,7 @@ impl Arena {
    /// and the device allows it, in system memory: Vulkan drivers fail an
    /// allocation rather than page like OpenGL ones, and wgpu's default error
    /// handler panics. `None` when neither has room.
-    fn create(&mut self, device: &wgpu::Device, capacity: u64) -> Option<wgpu::Buffer> {
+    fn create(&mut self, device: &wgpu::Device, capacity: u64) -> Option<(wgpu::Buffer, bool)> {
        let usage = self.usage | wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::COPY_SRC;
        #[cfg(test)]
        let local = (!self.video_memory_full)
@@ -146,6 +163,7 @@ impl Arena {
            .flatten();
        #[cfg(not(test))]
        let local = try_create(device, capacity * self.stride, usage);
+        let local = local.map(|buffer| (buffer, false));
        local.or_else(|| {
            // Mappable buffers are placed in host-visible memory, which the
            // allocator takes from system memory once video memory is full.
@@ -166,7 +184,7 @@ impl Arena {
                     (lower the render distance if frames slow down)"
                );
            }
-            Some(buffer)
+            Some((buffer, true))
        })
    }
    /// The rounded length a request of `vertices` occupies.
@@ -207,16 +225,13 @@ impl Arena {
        vertices: u64,
    ) -> Option<(u32, u64)> {
        let len = Self::span(vertices).min(self.page_limit);
-        for (i, page) in self.pages.iter_mut().enumerate() {
-            if let Some(page) = page
-                && let Some(start) = page.free.take(len)
-            {
-                return Some((i as u32, start));
-            }
+        if let Some(found) = self.alloc_existing(len) {
+            return Some(found);
        }
        let last = self.pages.len().saturating_sub(1);
        if let Some(page) = self.pages.last().and_then(Option::as_ref)
            && page.capacity < self.page_limit
+            && self.closing != Some(last as u32)
        {
            let current = page.capacity;
            let grown = (current * 2).max(current + len).min(self.page_limit);
@@ -235,7 +250,7 @@ impl Arena {
        .max(len)
        .min(self.page_limit);
        // A page just large enough when memory is short.
-        let (buffer, capacity) = match self.create(device, capacity) {
+        let ((buffer, host), capacity) = match self.create(device, capacity) {
            Some(buffer) => (buffer, capacity),
            None if capacity > len => (self.create(device, len)?, len),
            None => return None,
@@ -246,6 +261,7 @@ impl Arena {
            buffer,
            capacity,
            free,
+            host,
        };
        let index = self
            .pages
@@ -258,6 +274,96 @@ impl Arena {
        self.pages[index] = Some(page);
        Some((index as u32, start))
    }
+    /// A range of `vertices` in a page that exists already and is not being
+    /// emptied: never grows the arena.
+    pub fn alloc_existing(&mut self, vertices: u64) -> Option<(u32, u64)> {
+        let len = Self::span(vertices).min(self.page_limit);
+        let closing = self.closing;
+        self.pages
+            .iter_mut()
+            .enumerate()
+            .filter(|(i, _)| closing != Some(*i as u32))
+            .find_map(|(i, page)| Some((i as u32, page.as_mut()?.free.take(len)?)))
+    }
+    /// `alloc_existing` for a mesh moved off the closing page: only pages in
+    /// video memory, so compaction never pushes terrain into system memory.
+    pub fn alloc_moved(&mut self, vertices: u64) -> Option<(u32, u64)> {
+        let len = Self::span(vertices).min(self.page_limit);
+        let closing = self.closing;
+        self.pages
+            .iter_mut()
+            .enumerate()
+            .filter(|(i, p)| closing != Some(*i as u32) && p.as_ref().is_some_and(|p| !p.host))
+            .find_map(|(i, page)| Some((i as u32, page.as_mut()?.free.take(len)?)))
+    }
+    /// The page to empty when much of the arena is free ranges (video memory
+    /// that fragmentation keeps: a page goes back only once all of it is free):
+    /// the one with the fewest vertices in use that the other pages' free
+    /// ranges can take. `None` when the arena is dense enough or already
+    /// emptying a page.
+    pub fn sparsest(&self) -> Option<u32> {
+        self.sparsest_from(COMPACT_MIN_FREE)
+    }
+    /// `sparsest` for an arena with at least `min_free` bytes in free ranges.
+    fn sparsest_from(&self, min_free: u64) -> Option<u32> {
+        if self.closing.is_some() {
+            return None;
+        }
+        let pages = || {
+            self.pages
+                .iter()
+                .enumerate()
+                .filter_map(|(i, p)| Some((i, p.as_ref()?)))
+        };
+        let free: u64 = pages().map(|(_, p)| p.free_vertices()).sum();
+        let capacity: u64 = pages().map(|(_, p)| p.capacity).sum();
+        if free * self.stride < min_free || free * 2 < capacity {
+            return None;
+        }
+        // Moves only go to video-memory pages (`alloc_moved`).
+        let local_free: u64 = pages()
+            .filter(|(_, p)| !p.host)
+            .map(|(_, p)| p.free_vertices())
+            .sum();
+        pages()
+            .filter_map(|(i, p)| {
+                let used = p.capacity - p.free_vertices();
+                let own = if p.host { 0 } else { p.free_vertices() };
+                // The room elsewhere, less a quarter for first fit's gaps.
+                let elsewhere = (local_free - own) / 4 * 3;
+                // A page in system memory is emptied first.
+                (used > 0 && used <= elsewhere).then_some((!p.host, used, i as u32))
+            })
+            .min()
+            .map(|(_, _, i)| i)
+    }
+    /// Stops placing vertices in `page` until `reopen`.
+    pub fn close(&mut self, page: u32) {
+        self.closing = Some(page);
+    }
+    pub fn reopen(&mut self) {
+        self.closing = None;
+    }
+    pub fn closing(&self) -> Option<u32> {
+        self.closing
+    }
+    /// Records the copy of `vertices` from one range to another of other pages.
+    pub fn copy(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        from: (u32, u64),
+        to: (u32, u64),
+        vertices: u64,
+    ) {
+        debug_assert_ne!(from.0, to.0);
+        encoder.copy_buffer_to_buffer(
+            self.buffer(from.0),
+            from.1 * self.stride,
+            self.buffer(to.0),
+            to.1 * self.stride,
+            vertices * self.stride,
+        );
+    }
    pub fn release(&mut self, page: u32, start: u64, vertices: u64) {
        let len = Self::span(vertices).min(self.page_limit);
        self.pages[page as usize]
@@ -296,7 +402,7 @@ impl Arena {
        capacity: u64,
    ) -> bool {
        let capacity = capacity.next_multiple_of(GRAIN).min(self.page_limit);
-        let Some(buffer) = self.create(device, capacity) else {
+        let Some((buffer, host)) = self.create(device, capacity) else {
            return false;
        };
        let old = self.pages[page].as_mut().expect("live arena page");
@@ -304,6 +410,7 @@ impl Arena {
        encoder.copy_buffer_to_buffer(&old.buffer, 0, &buffer, 0, old.capacity * self.stride);
        let previous = old.capacity;
        old.buffer = buffer;
+        old.host = host;
        old.capacity = capacity;
        old.free.give(previous, capacity - previous);
        true
@@ -318,6 +425,9 @@ impl Arena {
                *page = None;
            }
        }
+        if self.closing.is_some_and(|page| !self.has_page(page)) {
+            self.closing = None;
+        }
        // Keep live page indices stable; later allocations reuse interior holes.
        while self.pages.last().is_some_and(Option::is_none) {
            self.pages.pop();
@@ -325,6 +435,7 @@ impl Arena {
    }
    pub fn clear(&mut self) {
        self.pages.clear();
+        self.closing = None;
    }
 }

@@ -407,6 +518,76 @@ mod tests {
        assert_eq!(read(&device, &queue, arena.buffer(page), next * 4), 9);
    }

+    #[test]
+    fn a_sparse_page_empties_into_the_others_and_is_reclaimed() {
+        let Some((device, queue)) = device() else {
+            eprintln!("no GPU adapter: skipped");
+            return;
+        };
+        let mut arena = Arena::new(&device, 4, GRAIN, false);
+        arena.page_limit = 4 * GRAIN;
+        // Eight ranges fill two pages, each holding its own number.
+        let ranges: Vec<(u32, u64)> = (0..8)
+            .map(|i| {
+                let range = alloc(&mut arena, &device, &queue, GRAIN).unwrap();
+                queue.write_buffer(
+                    arena.buffer(range.0),
+                    range.1 * 4,
+                    &(100 + i as u32).to_le_bytes(),
+                );
+                range
+            })
+            .collect();
+        assert_eq!(arena.pages.iter().flatten().count(), 2);
+        let (first, second) = (ranges[0].0, ranges[7].0);
+        assert_ne!(first, second);
+        // Fragmented: one range live in the first page, two in the second.
+        for (i, &(page, start)) in ranges.iter().enumerate() {
+            if ![0, 6, 7].contains(&i) {
+                arena.release(page, start, GRAIN);
+            }
+        }
+        // Dense enough arenas, and ones without room elsewhere, are left alone.
+        assert_eq!(arena.sparsest_from(u64::MAX), None);
+        assert_eq!(arena.sparsest_from(0), Some(first));
+        arena.close(first);
+        assert_eq!(
+            arena.sparsest_from(0),
+            None,
+            "one page is emptied at a time"
+        );
+        // New ranges avoid the closing page though it has room.
+        let (page, extra) = alloc(&mut arena, &device, &queue, GRAIN).unwrap();
+        assert_eq!(page, second);
+        arena.release(page, extra, GRAIN);
+        // Its live range moves, data included, and the page goes back.
+        let (page, start) = ranges[0];
+        let to = arena.alloc_existing(GRAIN).unwrap();
+        assert_eq!(to.0, second);
+        let mut encoder = device.create_command_encoder(&Default::default());
+        arena.copy(&mut encoder, (page, start), to, GRAIN);
+        queue.submit([encoder.finish()]);
+        arena.release(page, start, GRAIN);
+        assert_eq!(read(&device, &queue, arena.buffer(to.0), to.1 * 4), 100);
+        // Emptied but not trimmed yet: it stays closed, so uploads can't refill it.
+        assert_eq!(arena.closing(), Some(page));
+        let refill = alloc(&mut arena, &device, &queue, GRAIN).unwrap();
+        assert_ne!(refill.0, page);
+        arena.release(refill.0, refill.1, GRAIN);
+        let before = arena.bytes();
+        arena.trim();
+        assert_eq!(arena.bytes(), before - 4 * GRAIN * 4);
+        assert_eq!(arena.closing(), None);
+        // The others kept their ranges.
+        for i in [6, 7] {
+            let (page, start) = ranges[i];
+            assert_eq!(
+                read(&device, &queue, arena.buffer(page), start * 4),
+                100 + i as u32
+            );
+        }
+    }
+
    #[test]
    fn empty_pages_are_reclaimed_without_moving_live_ranges() {
        let Some((device, queue)) = device() else {
@@ -572,6 +753,9 @@ mod tests {
        queue.write_buffer(arena.buffer(grown), next * 4, &9u32.to_le_bytes());
        assert_eq!(read(&device, &queue, arena.buffer(page), start * 4), 7);
        assert_eq!(read(&device, &queue, arena.buffer(grown), next * 4), 9);
+        // Compaction never moves terrain into a page in system memory.
+        assert!(arena.pages[page as usize].as_ref().unwrap().host);
+        assert_eq!(arena.alloc_moved(GRAIN), None);
    }

    #[test]
@@ -46,12 +46,13 @@ pub const TRANSLUCENT_GLINT_ITEM_OVERLAY: u32 = 33;
 /// drawn like an ordinary entity, pulled toward the camera.
 pub const TEXT_POLYGON_OFFSET_OVERLAY: u32 = 35;

-/// The material of a quad by its overlay (`MATERIALS` order).
+/// The material of a quad by its overlay (`MATERIALS` order): the overlay is the layer's low 16
+/// bits, as entity.wgsl reads it; HDR output's tier rides in the high ones.
 fn material(layer: u32, oit: bool) -> usize {
    if oit && layer & OIT_ENTITY != 0 {
        return 9;
    }
-    match layer {
+    match layer & 0xffff {
        TEXT_POLYGON_OFFSET_OVERLAY => 1,
        11 => 2,
        12 => 3,
@@ -213,6 +214,15 @@ mod tests {
        );
    }

+    #[test]
+    fn a_tier_in_the_high_bits_keeps_the_material() {
+        for layer in [0u32, 11, 12, 15, 32, 33, 35, OIT_ENTITY] {
+            for oit in [false, true] {
+                assert_eq!(material(layer | 4 << 16, oit), material(layer, oit));
+            }
+        }
+    }
+
    #[test]
    fn oit_entity_quads_are_a_last_material_only_when_on() {
        let quad = |layer: u32, x: f32| {
@@ -63,6 +63,8 @@ pub struct Call {

 pub struct Flat {
    pub solid: wgpu::RenderPipeline,
+    /// The solid draws as the water mirror's camera draws them (`fs_solid_mirror`).
+    pub solid_mirror: wgpu::RenderPipeline,
    pub translucent: wgpu::RenderPipeline,
    flatten: wgpu::ComputePipeline,
    compute_layout: wgpu::BindGroupLayout,
@@ -117,29 +119,52 @@ pub struct Flat {
 /// sides it shows the eye (`mesher::Sides`), so it counts sections.
 pub const MIN_SECTIONS: usize = 1600;

-/// Whether flat draws apply: the backend emulates multi-draw, and vertex
-/// shaders can read storage buffers large enough for an index page.
+/// Whether flat draws exist: vertex shaders can read storage buffers large
+/// enough for an index page. A shader pack's terrain draws flat wherever they
+/// do, since only there does it read each quad's face normal and `mc_Entity`;
+/// frames without one draw flat only where `for_vanilla` says.
 /// `HORIZON_FLAT_DRAWS=1` draws every frame flat, `0` none.
 pub fn wanted(adapter: &wgpu::Adapter, device: &wgpu::Device) -> bool {
-    match std::env::var("HORIZON_FLAT_DRAWS").as_deref() {
-        Ok("0") => return false,
-        Ok("1") => return supported(adapter, device),
-        _ => {}
-    }
-    let info = adapter.get_info();
-    (info.backend == wgpu::Backend::Metal || is_broken_intel_vulkan(&info))
-        && supported(adapter, device)
+    std::env::var("HORIZON_FLAT_DRAWS").as_deref() != Ok("0") && supported(adapter, device)
 }

-/// Intel Gen11 (Ice Lake) ANV Vulkan driver has broken `first_instance` for instance-step
-/// vertex attributes (#3529), causing terrain sections to be drawn with another section's origin
-/// and flicker.
+/// Whether frames without a shader pack's terrain draw flat: where the backend
+/// emulates multi-draw (Metal, past `MIN_SECTIONS`), on Intel Gen11/Gen12's Vulkan
+/// driver, or with `HORIZON_FLAT_DRAWS=1`. Elsewhere per-section draws stay.
+pub fn for_vanilla(info: &wgpu::AdapterInfo) -> bool {
+    std::env::var("HORIZON_FLAT_DRAWS").as_deref() == Ok("1")
+        || info.backend == wgpu::Backend::Metal
+        || is_broken_intel_vulkan(info)
+}
+
+/// Intel Gen11 (Ice Lake) and Gen12 (Tiger Lake, Rocket Lake, Alder Lake,
+/// Raptor Lake) ANV Vulkan drivers have broken `first_instance` for
+/// instance-step vertex attributes (#3529, #4599), causing terrain sections to
+/// be drawn with another section's origin and flicker.
 pub fn is_broken_intel_vulkan(info: &wgpu::AdapterInfo) -> bool {
    info.backend == wgpu::Backend::Vulkan
        && info.vendor == 0x8086
-        && (info.name.contains("ICL")
-            || info.name.contains("Ice Lake")
-            || (info.device >= 0x8a50 && info.device <= 0x8a71))
+        && (matches!(
+            info.device,
+            0x8a50..=0x8a71 // Gen11: Ice Lake
+                | 0x9a40..=0x9a7f // Gen12: Tiger Lake
+                | 0x4c80..=0x4c9a // Gen12: Rocket Lake
+                | 0x4600..=0x46ff // Gen12: Alder Lake (incl. 0x46a8 in #4599)
+                | 0xa700..=0xa7ff // Gen12: Raptor Lake
+        ) || [
+            "ICL",
+            "Ice Lake",
+            "TGL",
+            "Tiger Lake",
+            "RKL",
+            "Rocket Lake",
+            "ADL",
+            "Alder Lake",
+            "RPL",
+            "Raptor Lake",
+        ]
+        .iter()
+        .any(|tag| info.name.contains(tag)))
 }

 fn supported(adapter: &wgpu::Adapter, device: &wgpu::Device) -> bool {
@@ -261,7 +286,7 @@ fn plan(
 }

 impl Flat {
-    /// `pipeline(layout, label, vertex entry, fragment entry, blend)` builds a
+    /// `pipeline(layout, label, fragment entry, blend, cull)` builds a
    /// terrain pipeline as the per-section ones, without the origin buffer.
    pub fn new(
        device: &wgpu::Device,
@@ -273,6 +298,7 @@ impl Flat {
            &str,
            &str,
            Option<wgpu::BlendState>,
+            Option<wgpu::Face>,
        ) -> wgpu::RenderPipeline,
    ) -> Self {
        let vertex = wgpu::ShaderStages::VERTEX;
@@ -326,13 +352,23 @@ impl Flat {
        let flatten = compute_pipeline(&compute_layout, "flatten");
        let flatten_seen = compute_pipeline(&seen_layout, "flatten_seen");
        let storage_usage = wgpu::BufferUsages::STORAGE;
+        let back = Some(wgpu::Face::Back);
        Self {
-            solid: pipeline(&layout, "Terrain solid (flat)", "fs_solid", None),
+            solid: pipeline(&layout, "Terrain solid (flat)", "fs_solid", None, back),
+            // The mirror flips the winding: its solid terrain culls the front.
+            solid_mirror: pipeline(
+                &layout,
+                "Terrain solid mirrored (flat)",
+                "fs_solid_mirror",
+                None,
+                Some(wgpu::Face::Front),
+            ),
            translucent: pipeline(
                &layout,
                "Terrain translucent (flat)",
                "fs_translucent",
                Some(wgpu::BlendState::ALPHA_BLENDING),
+                back,
            ),
            flatten,
            compute_layout,
@@ -708,6 +744,23 @@ impl Flat {
            pass.draw_indexed(call.first..call.first + call.count, 0, 0..1);
        }
    }
+    /// Draws `calls` without their index buffer, `instances` times: a shader pack's geometry
+    /// stage reads the indices itself (`hz_indices`) and stands for one emitted triangle per
+    /// instance.
+    pub fn draw_geometry<'a>(
+        &self,
+        pass: &mut wgpu::RenderPass<'_>,
+        calls: &[Call],
+        vertices: impl Fn(u32) -> &'a wgpu::Buffer,
+        page: impl Fn(&mut wgpu::RenderPass<'_>, u32),
+        instances: u32,
+    ) {
+        for call in calls {
+            self.bind_page(pass, call.page, &vertices);
+            page(pass, call.page);
+            pass.draw(call.first..call.first + call.count, 0..instances);
+        }
+    }
    /// Draws phase 2's calls, as `flatten_phase2` left them.
    pub fn draw_phase2<'a>(
        &self,
@@ -1,7 +1,9 @@
 //! Frame generation: FSR 3.1's frame interpolation will show a frame halfway between each
-//! two real ones. So far this holds its optical flow; the interpolation and the setting
-//! that runs them come next.
+//! two real ones. So far this holds its optical flow and interpolation; the setting that
+//! runs them comes next.

-// Unused until the interpolation and the renderer use it.
+// Unused until the renderer runs them.
+#[allow(dead_code)]
+mod interpolation;
 #[allow(dead_code)]
 mod optical_flow;
@@ -0,0 +1,806 @@
+//! FSR 3.1's frame interpolation (AMD FidelityFX SDK 1.1.4, `ffx_frameinterpolation*`,
+//! MIT), ported to WGSL (`interpolation.wgsl`): the frame halfway between the previous
+//! real frame and this one, from the camera's motion vectors, the optical flow
+//! (`optical_flow.rs`) and the depth.
+//!
+//! The passes and their order are `ffxFrameInterpolationPrepare` then
+//! `ffxFrameInterpolationDispatch`'s: dilate the depth and motion vectors and estimate
+//! the previous frame's depth; estimate the made frame's depth; splat the game's and the
+//! optical flow's vectors to the made frame's pixels (atomic maximums of packed
+//! priorities and vectors) and fill the game field's holes from a pyramid; mask what each
+//! frame can't see; blend the two frames along both fields; fill what is left from a
+//! pyramid of the result. What differs from AMD's, all forced by WGSL or by Horizon:
+//! the game's motion vectors are computed from the depth and `Inputs::reproject` (the
+//! camera's, so what moves on its own relies on the optical flow); textures AMD updates
+//! with image atomics are storage buffers; SPD's single-pass pyramids are a pass per
+//! level; and there is no HUD-less pass, as Horizon draws its HUD over the made frame.
+
+use glam::Mat4;
+
+/// One real frame's inputs.
+pub struct Inputs<'a> {
+    /// This frame's colour without the hand and HUD: `display` size, a filterable
+    /// float texture (gamma-encoded RGB, the swapchain's values) that can be copied from.
+    pub color: &'a wgpu::TextureView,
+    /// This frame's depth: `Depth32Float` at `render_size`, reversed (1 at the near
+    /// plane, 0 at the far one), finite, jittered by `jitter`.
+    pub depth: &'a wgpu::TextureView,
+    pub render_size: [u32; 2],
+    /// The projection's sub-pixel jitter this frame, in render pixels (FSR's
+    /// `jitterOffset`); zero without TAA.
+    pub jitter: [f32; 2],
+    /// This frame's unjittered clip space to the previous frame's (camera-relative, as
+    /// `world_post::reprojection`): the motion vectors are the camera's, from this and
+    /// the depth.
+    pub reproject: Mat4,
+    pub near: f32,
+    pub far: f32,
+    /// Vertical field of view, radians.
+    pub fov_y: f32,
+    /// The previous frame is unrelated (first frame, resize, teleport): show this one.
+    pub reset: bool,
+    /// The optical flow from the previous frame's `color` to this one's
+    /// (`OpticalFlow::vectors`, `scene_change`).
+    pub flow_vectors: &'a wgpu::TextureView,
+    pub scene_change: &'a wgpu::Buffer,
+}
+
+/// `interpolation.wgsl`'s `Params`.
+#[repr(C)]
+#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
+struct Params {
+    reproject: [[f32; 4]; 4],
+    device_to_view: [f32; 4],
+    render_size: [i32; 2],
+    display_size: [i32; 2],
+    jitter: [f32; 2],
+    optical_flow_scale: [f32; 2],
+    optical_flow_size: [i32; 2],
+    reset: u32,
+    tan_half_fov: f32,
+    level_size: [i32; 2],
+    _pad: [u32; 2],
+}
+
+/// The game vector field pyramid's levels (`LoadInpaintedGameFieldMv`) and the
+/// inpainting pyramid's (`ComputeInpainting`).
+const GAME_LEVELS: u32 = 11;
+const INPAINTING_LEVELS: u32 = 10;
+
+struct Pipelines {
+    prepare: wgpu::ComputePipeline,
+    setup: wgpu::ComputePipeline,
+    reconstruct_previous_depth: wgpu::ComputePipeline,
+    game_motion_vector_field: wgpu::ComputePipeline,
+    game_field_pyramid_first: wgpu::ComputePipeline,
+    game_field_pyramid: wgpu::ComputePipeline,
+    optical_flow_vector_field: wgpu::ComputePipeline,
+    disocclusion_mask: wgpu::ComputePipeline,
+    interpolate: wgpu::ComputePipeline,
+    inpainting_pyramid_first: wgpu::ComputePipeline,
+    inpainting_pyramid: wgpu::ComputePipeline,
+    inpainting: wgpu::ComputePipeline,
+}
+
+/// A texture with a view of each of its levels (`levels`, for writing one from the one
+/// above) and of all of them.
+struct Pyramid {
+    all: wgpu::TextureView,
+    levels: Vec<wgpu::TextureView>,
+    sizes: Vec<[u32; 2]>,
+}
+
+/// What is sized like the world's render.
+struct RenderTargets {
+    size: [u32; 2],
+    dilated_depth: wgpu::TextureView,
+    dilated_mv: wgpu::TextureView,
+    rec_prev_depth: wgpu::Buffer,
+    rec_interp_depth: wgpu::Buffer,
+    game_x: wgpu::Buffer,
+    game_y: wgpu::Buffer,
+    of_x: wgpu::Buffer,
+    of_y: wgpu::Buffer,
+    disocclusion: wgpu::TextureView,
+    game_pyramid: Pyramid,
+}
+
+pub struct Interpolation {
+    display: [u32; 2],
+    pipelines: Pipelines,
+    sampler: wgpu::Sampler,
+    /// The passes' constants, and each pyramid level's.
+    params: wgpu::Buffer,
+    game_level_params: Vec<wgpu::Buffer>,
+    inpainting_level_params: Vec<wgpu::Buffer>,
+    counters: wgpu::Buffer,
+    interpolated: wgpu::TextureView,
+    output: wgpu::TextureView,
+    inpainting_pyramid: Pyramid,
+    /// The last dispatch's colour (`PREVIOUS_INTERPOLATION_SOURCE`), made on the first.
+    previous: Option<wgpu::Texture>,
+    render: Option<RenderTargets>,
+}
+
+fn texture(
+    device: &wgpu::Device,
+    label: &str,
+    size: [u32; 2],
+    format: wgpu::TextureFormat,
+    levels: u32,
+) -> wgpu::Texture {
+    device.create_texture(&wgpu::TextureDescriptor {
+        label: Some(label),
+        size: wgpu::Extent3d {
+            width: size[0].max(1),
+            height: size[1].max(1),
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: levels,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format,
+        usage: wgpu::TextureUsages::STORAGE_BINDING
+            | wgpu::TextureUsages::TEXTURE_BINDING
+            | wgpu::TextureUsages::COPY_SRC,
+        view_formats: &[],
+    })
+}
+
+fn storage(device: &wgpu::Device, label: &str, size: u64) -> wgpu::Buffer {
+    device.create_buffer(&wgpu::BufferDescriptor {
+        label: Some(label),
+        size: size.max(4),
+        usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
+        mapped_at_creation: false,
+    })
+}
+
+fn uniform(device: &wgpu::Device) -> wgpu::Buffer {
+    device.create_buffer(&wgpu::BufferDescriptor {
+        label: Some("Frame interpolation constants"),
+        size: std::mem::size_of::<Params>() as u64,
+        usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+        mapped_at_creation: false,
+    })
+}
+
+/// Levels of `base >> (i + 1)` for `i` below `max`, while both sides are 1 or more.
+fn pyramid(device: &wgpu::Device, label: &str, base: [u32; 2], max: u32) -> Pyramid {
+    let sizes: Vec<[u32; 2]> = (0..max)
+        .map(|i| base.map(|v| v >> (i + 1)))
+        .take_while(|s| s[0] >= 1 && s[1] >= 1)
+        .collect();
+    let levels = (sizes.len() as u32).max(1);
+    let t = texture(
+        device,
+        label,
+        base.map(|v| (v / 2).max(1)),
+        wgpu::TextureFormat::Rgba16Float,
+        levels,
+    );
+    Pyramid {
+        all: t.create_view(&Default::default()),
+        levels: (0..levels)
+            .map(|i| {
+                t.create_view(&wgpu::TextureViewDescriptor {
+                    base_mip_level: i,
+                    mip_level_count: Some(1),
+                    ..Default::default()
+                })
+            })
+            .collect(),
+        sizes,
+    }
+}
+
+impl RenderTargets {
+    fn new(device: &wgpu::Device, size: [u32; 2]) -> Self {
+        let view = |t: wgpu::Texture| t.create_view(&Default::default());
+        let field = |label| storage(device, label, u64::from(size[0] * size[1]) * 4);
+        Self {
+            size,
+            dilated_depth: view(texture(
+                device,
+                "Frame interpolation dilated depth",
+                size,
+                wgpu::TextureFormat::R32Float,
+                1,
+            )),
+            dilated_mv: view(texture(
+                device,
+                "Frame interpolation dilated motion vectors",
+                size,
+                wgpu::TextureFormat::Rg32Float,
+                1,
+            )),
+            rec_prev_depth: field("Frame interpolation previous depth"),
+            rec_interp_depth: field("Frame interpolation interpolated depth"),
+            game_x: field("Frame interpolation game vectors x"),
+            game_y: field("Frame interpolation game vectors y"),
+            of_x: field("Frame interpolation flow vectors x"),
+            of_y: field("Frame interpolation flow vectors y"),
+            disocclusion: view(texture(
+                device,
+                "Frame interpolation disocclusion",
+                size,
+                wgpu::TextureFormat::Rgba8Unorm,
+                1,
+            )),
+            game_pyramid: pyramid(
+                device,
+                "Frame interpolation game vector pyramid",
+                size,
+                GAME_LEVELS,
+            ),
+        }
+    }
+}
+
+fn bind(
+    device: &wgpu::Device,
+    pipeline: &wgpu::ComputePipeline,
+    entries: &[(u32, wgpu::BindingResource)],
+) -> wgpu::BindGroup {
+    let entries: Vec<_> = entries
+        .iter()
+        .map(|(binding, resource)| wgpu::BindGroupEntry {
+            binding: *binding,
+            resource: resource.clone(),
+        })
+        .collect();
+    device.create_bind_group(&wgpu::BindGroupDescriptor {
+        label: Some("Frame interpolation"),
+        layout: &pipeline.get_bind_group_layout(0),
+        entries: &entries,
+    })
+}
+
+fn view(v: &wgpu::TextureView) -> wgpu::BindingResource<'_> {
+    wgpu::BindingResource::TextureView(v)
+}
+
+fn whole(b: &wgpu::Buffer) -> wgpu::BindingResource<'_> {
+    b.as_entire_binding()
+}
+
+/// `setupDeviceDepthToViewSpaceDepthParams` for inverted, finite depth, in blocks
+/// (`viewSpaceToMetersFactor` 1).
+fn device_to_view(near: f32, far: f32, fov_y: f32, aspect: f32) -> [f32; 4] {
+    let (f_min, f_max) = (near.max(far), near.min(far));
+    let q = f_max / (f_min - f_max);
+    let cot_half_fov = (0.5 * fov_y).cos() / (0.5 * fov_y).sin();
+    [-q, q * f_min, aspect / cot_half_fov, 1.0 / cot_half_fov]
+}
+
+impl Interpolation {
+    /// For frames of `display` size; the render size may change between dispatches.
+    pub fn new(device: &wgpu::Device, display: [u32; 2]) -> Self {
+        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Frame interpolation"),
+            source: wgpu::ShaderSource::Wgsl(include_str!("interpolation.wgsl").into()),
+        });
+        let pipeline = |entry: &str| {
+            device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
+                label: Some(entry),
+                layout: None,
+                module: &module,
+                entry_point: Some(entry),
+                compilation_options: Default::default(),
+                cache: None,
+            })
+        };
+        let view = |t: wgpu::Texture| t.create_view(&Default::default());
+        Self {
+            display,
+            pipelines: Pipelines {
+                prepare: pipeline("prepare_pass"),
+                setup: pipeline("setup_pass"),
+                reconstruct_previous_depth: pipeline("reconstruct_previous_depth_pass"),
+                game_motion_vector_field: pipeline("game_motion_vector_field_pass"),
+                game_field_pyramid_first: pipeline("game_field_pyramid_first_pass"),
+                game_field_pyramid: pipeline("game_field_pyramid_pass"),
+                optical_flow_vector_field: pipeline("optical_flow_vector_field_pass"),
+                disocclusion_mask: pipeline("disocclusion_mask_pass"),
+                interpolate: pipeline("interpolate_pass"),
+                inpainting_pyramid_first: pipeline("inpainting_pyramid_first_pass"),
+                inpainting_pyramid: pipeline("inpainting_pyramid_pass"),
+                inpainting: pipeline("inpainting_pass"),
+            },
+            sampler: device.create_sampler(&wgpu::SamplerDescriptor {
+                label: Some("Frame interpolation"),
+                mag_filter: wgpu::FilterMode::Linear,
+                min_filter: wgpu::FilterMode::Linear,
+                ..Default::default()
+            }),
+            params: uniform(device),
+            game_level_params: (0..GAME_LEVELS).map(|_| uniform(device)).collect(),
+            inpainting_level_params: (0..INPAINTING_LEVELS).map(|_| uniform(device)).collect(),
+            counters: storage(device, "Frame interpolation counters", 8),
+            interpolated: view(texture(
+                device,
+                "Frame interpolation",
+                display,
+                wgpu::TextureFormat::Rgba16Float,
+                1,
+            )),
+            output: view(texture(
+                device,
+                "Interpolated frame",
+                display,
+                wgpu::TextureFormat::Rgba16Float,
+                1,
+            )),
+            inpainting_pyramid: pyramid(
+                device,
+                "Frame interpolation inpainting pyramid",
+                display,
+                INPAINTING_LEVELS,
+            ),
+            previous: None,
+            render: None,
+        }
+    }
+
+    /// The frame halfway between the previous dispatch's `color` and this one's, into
+    /// `output`. Keeps what it needs of this frame for the next dispatch.
+    pub fn dispatch(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        encoder: &mut wgpu::CommandEncoder,
+        inputs: &Inputs,
+    ) {
+        let color = inputs.color.texture();
+        let mut reset = inputs.reset;
+        if self
+            .previous
+            .as_ref()
+            .is_none_or(|p| p.size() != color.size() || p.format() != color.format())
+        {
+            self.previous = Some(device.create_texture(&wgpu::TextureDescriptor {
+                label: Some("Frame interpolation previous frame"),
+                size: color.size(),
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: color.format(),
+                usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+                view_formats: &[],
+            }));
+            reset = true;
+        }
+        if self
+            .render
+            .as_ref()
+            .is_none_or(|r| r.size != inputs.render_size)
+        {
+            self.render = Some(RenderTargets::new(device, inputs.render_size));
+            reset = true;
+        }
+        let r = self.render.as_ref().expect("made above");
+        let previous_texture = self.previous.as_ref().expect("made above");
+        let previous = previous_texture.create_view(&Default::default());
+        let display = self.display.map(|v| v as i32);
+        let render = inputs.render_size.map(|v| v as i32);
+        let flow_size = self
+            .display
+            .map(|v| v.div_ceil(super::optical_flow::BLOCK_SIZE) as i32);
+        let base = Params {
+            reproject: inputs.reproject.to_cols_array_2d(),
+            device_to_view: device_to_view(
+                inputs.near,
+                inputs.far,
+                inputs.fov_y,
+                render[0] as f32 / render[1].max(1) as f32,
+            ),
+            render_size: render,
+            display_size: display,
+            jitter: inputs.jitter,
+            optical_flow_scale: self.display.map(|v| 1.0 / v as f32),
+            optical_flow_size: flow_size,
+            reset: u32::from(reset),
+            tan_half_fov: (0.5 * inputs.fov_y).tan() * render[0] as f32 / render[1].max(1) as f32,
+            level_size: [0; 2],
+            _pad: [0; 2],
+        };
+        queue.write_buffer(&self.params, 0, bytemuck::bytes_of(&base));
+        let level_params = |buffers: &[wgpu::Buffer], sizes: &[[u32; 2]]| {
+            for (buffer, size) in buffers.iter().zip(sizes) {
+                let params = Params {
+                    level_size: size.map(|v| v as i32),
+                    ..base
+                };
+                queue.write_buffer(buffer, 0, bytemuck::bytes_of(&params));
+            }
+        };
+        level_params(&self.game_level_params, &r.game_pyramid.sizes);
+        level_params(
+            &self.inpainting_level_params,
+            &self.inpainting_pyramid.sizes,
+        );
+        for b in [
+            &r.rec_prev_depth,
+            &r.rec_interp_depth,
+            &r.game_x,
+            &r.game_y,
+            &r.of_x,
+            &r.of_y,
+        ] {
+            encoder.clear_buffer(b, 0, None);
+        }
+        if reset {
+            encoder.clear_buffer(&self.counters, 0, None);
+        }
+        let p = &self.pipelines;
+        let params = || whole(&self.params);
+        let sampler = || wgpu::BindingResource::Sampler(&self.sampler);
+        let groups =
+            |pipeline, entries: &[(u32, wgpu::BindingResource)]| bind(device, pipeline, entries);
+        let prepare = groups(
+            &p.prepare,
+            &[
+                (0, params()),
+                (2, view(inputs.depth)),
+                (5, view(&r.dilated_depth)),
+                (6, view(&r.dilated_mv)),
+                (9, whole(&r.rec_prev_depth)),
+            ],
+        );
+        let setup = groups(
+            &p.setup,
+            &[
+                (0, params()),
+                (22, whole(inputs.scene_change)),
+                (23, whole(&self.counters)),
+            ],
+        );
+        let colors = || {
+            [
+                (3, view(inputs.color)),
+                (4, view(&previous)),
+                (1, sampler()),
+            ]
+        };
+        let reconstruct = groups(
+            &p.reconstruct_previous_depth,
+            &[
+                (0, params()),
+                (7, view(&r.dilated_depth)),
+                (8, view(&r.dilated_mv)),
+                (10, whole(&r.rec_interp_depth)),
+            ],
+        );
+        let mut entries = vec![
+            (0, params()),
+            (7, view(&r.dilated_depth)),
+            (8, view(&r.dilated_mv)),
+            (13, whole(&r.game_x)),
+            (14, whole(&r.game_y)),
+        ];
+        entries.extend(colors());
+        let game_field = groups(&p.game_motion_vector_field, &entries);
+        let game_pyramid: Vec<_> = (0..r.game_pyramid.sizes.len())
+            .map(|i| {
+                let mut entries = vec![
+                    (0, whole(&self.game_level_params[i])),
+                    (26, view(&r.game_pyramid.levels[i])),
+                ];
+                if i == 0 {
+                    entries.extend([(15, whole(&r.game_x)), (16, whole(&r.game_y))]);
+                    groups(&p.game_field_pyramid_first, &entries)
+                } else {
+                    entries.push((25, view(&r.game_pyramid.levels[i - 1])));
+                    groups(&p.game_field_pyramid, &entries)
+                }
+            })
+            .collect();
+        let mut entries = vec![
+            (0, params()),
+            (21, view(inputs.flow_vectors)),
+            (17, whole(&r.of_x)),
+            (18, whole(&r.of_y)),
+        ];
+        entries.extend(colors());
+        let flow_field = groups(&p.optical_flow_vector_field, &entries);
+        let game_mv = || {
+            [
+                (15, whole(&r.game_x)),
+                (16, whole(&r.game_y)),
+                (27, view(&r.game_pyramid.all)),
+            ]
+        };
+        let mut entries = vec![
+            (0, params()),
+            (7, view(&r.dilated_depth)),
+            (11, whole(&r.rec_prev_depth)),
+            (12, whole(&r.rec_interp_depth)),
+            (29, view(&r.disocclusion)),
+        ];
+        entries.extend(game_mv());
+        let disocclusion = groups(&p.disocclusion_mask, &entries);
+        let mut entries = vec![
+            (0, params()),
+            (19, whole(&r.of_x)),
+            (20, whole(&r.of_y)),
+            (24, whole(&self.counters)),
+            (30, view(&r.disocclusion)),
+            (31, view(&self.interpolated)),
+        ];
+        entries.extend(game_mv());
+        entries.extend(colors());
+        let interpolate = groups(&p.interpolate, &entries);
+        let inpainting_pyramid: Vec<_> = (0..self.inpainting_pyramid.sizes.len())
+            .map(|i| {
+                let mut entries = vec![
+                    (0, whole(&self.inpainting_level_params[i])),
+                    (26, view(&self.inpainting_pyramid.levels[i])),
+                ];
+                if i == 0 {
+                    entries.push((32, view(&self.interpolated)));
+                    groups(&p.inpainting_pyramid_first, &entries)
+                } else {
+                    entries.push((25, view(&self.inpainting_pyramid.levels[i - 1])));
+                    groups(&p.inpainting_pyramid, &entries)
+                }
+            })
+            .collect();
+        let inpainting = groups(
+            &p.inpainting,
+            &[
+                (0, params()),
+                (28, view(&self.inpainting_pyramid.all)),
+                (32, view(&self.interpolated)),
+                (33, view(&self.output)),
+            ],
+        );
+        let groups_for = |size: [u32; 2]| (size[0].div_ceil(8), size[1].div_ceil(8));
+        let (rx, ry) = groups_for(inputs.render_size);
+        let (dx, dy) = groups_for(self.display);
+        let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
+            label: Some("Frame interpolation"),
+            timestamp_writes: None,
+        });
+        let mut run = |pipeline: &wgpu::ComputePipeline, group: &wgpu::BindGroup, (x, y)| {
+            pass.set_pipeline(pipeline);
+            pass.set_bind_group(0, group, &[]);
+            pass.dispatch_workgroups(x, y, 1);
+        };
+        run(&p.prepare, &prepare, (rx, ry));
+        run(&p.setup, &setup, (1, 1));
+        if !reset {
+            run(&p.reconstruct_previous_depth, &reconstruct, (rx, ry));
+            run(&p.game_motion_vector_field, &game_field, (rx, ry));
+            for (i, (group, size)) in game_pyramid.iter().zip(&r.game_pyramid.sizes).enumerate() {
+                let pipeline = if i == 0 {
+                    &p.game_field_pyramid_first
+                } else {
+                    &p.game_field_pyramid
+                };
+                run(pipeline, group, groups_for(*size));
+            }
+            run(
+                &p.optical_flow_vector_field,
+                &flow_field,
+                groups_for(flow_size.map(|v| v as u32)),
+            );
+            run(&p.disocclusion_mask, &disocclusion, (rx, ry));
+        }
+        run(&p.interpolate, &interpolate, (dx, dy));
+        for (i, (group, size)) in inpainting_pyramid
+            .iter()
+            .zip(&self.inpainting_pyramid.sizes)
+            .enumerate()
+        {
+            let pipeline = if i == 0 {
+                &p.inpainting_pyramid_first
+            } else {
+                &p.inpainting_pyramid
+            };
+            run(pipeline, group, groups_for(*size));
+        }
+        run(&p.inpainting, &inpainting, (dx, dy));
+        drop(pass);
+        encoder.copy_texture_to_texture(
+            color.as_image_copy(),
+            previous_texture.as_image_copy(),
+            color.size(),
+        );
+    }
+
+    /// The interpolated frame: `display` size, `Rgba16Float`, sampled; its colour is
+    /// encoded as `Inputs::color`'s is.
+    pub fn output(&self) -> &wgpu::TextureView {
+        &self.output
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::optical_flow::{OpticalFlow, tests as of};
+    use super::*;
+
+    #[test]
+    fn shader_validates() {
+        let module = naga::front::wgsl::parse_str(include_str!("interpolation.wgsl")).unwrap();
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::empty(),
+        )
+        .validate(&module)
+        .unwrap();
+    }
+
+    fn f16(bits: u16) -> f32 {
+        let (sign, exp, frac) = (bits >> 15, (bits >> 10) & 0x1f, bits & 0x3ff);
+        let v = match exp {
+            0 => f32::from(frac) / 1024.0 * 2f32.powi(-14),
+            31 => f32::INFINITY,
+            e => (1.0 + f32::from(frac) / 1024.0) * 2f32.powi(i32::from(e) - 15),
+        };
+        if sign == 1 { -v } else { v }
+    }
+
+    /// Runs `frames` (pattern shifts) through the optical flow and the interpolation with
+    /// a camera that moves by `reproject` each frame, and returns the mean error of the
+    /// last made frame's interior against `expected`, and the last two real frames'.
+    fn interpolate(
+        seed: u32,
+        shifts: &[[i32; 2]],
+        reproject: Mat4,
+        expected: [i32; 2],
+    ) -> Option<[f32; 3]> {
+        let (device, queue) = of::device()?;
+        let size = [512, 288];
+        let depth = device.create_texture(&wgpu::TextureDescriptor {
+            label: None,
+            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: wgpu::TextureFormat::Depth32Float,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
+            view_formats: &[],
+        });
+        let depth = depth.create_view(&Default::default());
+        let mut encoder = device.create_command_encoder(&Default::default());
+        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: None,
+            color_attachments: &[],
+            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                view: &depth,
+                depth_ops: Some(wgpu::Operations {
+                    load: wgpu::LoadOp::Clear(0.01),
+                    store: wgpu::StoreOp::Store,
+                }),
+                stencil_ops: None,
+            }),
+            ..Default::default()
+        });
+        queue.submit([encoder.finish()]);
+        let mut flow = OpticalFlow::new(&device, size);
+        let mut interpolation = Interpolation::new(&device, size);
+        let frames: Vec<_> = shifts
+            .iter()
+            .map(|s| {
+                let pixels = of::pattern(size, seed, *s);
+                // COPY_SRC as the frame generation's world texture has.
+                let t = device.create_texture(&wgpu::TextureDescriptor {
+                    label: None,
+                    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: wgpu::TextureFormat::Rgba8Unorm,
+                    usage: wgpu::TextureUsages::TEXTURE_BINDING
+                        | wgpu::TextureUsages::COPY_DST
+                        | wgpu::TextureUsages::COPY_SRC,
+                    view_formats: &[],
+                });
+                queue.write_texture(
+                    t.as_image_copy(),
+                    &pixels,
+                    wgpu::TexelCopyBufferLayout {
+                        offset: 0,
+                        bytes_per_row: Some(size[0] * 4),
+                        rows_per_image: None,
+                    },
+                    t.size(),
+                );
+                (t.create_view(&Default::default()), pixels)
+            })
+            .collect();
+        for (i, (color, _)) in frames.iter().enumerate() {
+            let mut encoder = device.create_command_encoder(&Default::default());
+            flow.dispatch(&device, &queue, &mut encoder, color, i == 0);
+            interpolation.dispatch(
+                &device,
+                &queue,
+                &mut encoder,
+                &Inputs {
+                    color,
+                    depth: &depth,
+                    render_size: size,
+                    jitter: [0.0; 2],
+                    reproject: if i == 0 { Mat4::IDENTITY } else { reproject },
+                    near: 0.05,
+                    far: 512.0,
+                    fov_y: 1.2,
+                    reset: i == 0,
+                    flow_vectors: flow.vectors(),
+                    scene_change: flow.scene_change(),
+                },
+            );
+            queue.submit([encoder.finish()]);
+        }
+        let out = of::read(&device, &queue, interpolation.output.texture(), 8);
+        let made: Vec<f32> = out
+            .chunks(2)
+            .map(|c| f16(u16::from_le_bytes([c[0], c[1]])))
+            .collect();
+        let truth = of::pattern(size, seed, expected);
+        let n = frames.len();
+        let error = |pixels: &dyn Fn(usize) -> f32| {
+            let (mut sum, mut count) = (0.0, 0.0);
+            for y in 32..size[1] as usize - 32 {
+                for x in 32..size[0] as usize - 32 {
+                    for c in 0..3 {
+                        let i = (y * size[0] as usize + x) * 4 + c;
+                        sum += (pixels(i) - f32::from(truth[i]) / 255.0).abs();
+                        count += 1.0;
+                    }
+                }
+            }
+            sum / count
+        };
+        Some([
+            error(&|i| made[i]),
+            error(&|i| f32::from(frames[n - 2].1[i]) / 255.0),
+            error(&|i| f32::from(frames[n - 1].1[i]) / 255.0),
+        ])
+    }
+
+    /// Something moving on its own (the camera still): the optical flow puts the made
+    /// frame's blocks halfway where its colours match better than the still camera's
+    /// (FSR prefers the game's vectors unless they clearly don't: primaries make it
+    /// clear). The first 10 frames after a reset use the game's vectors only.
+    #[test]
+    fn moves_what_the_optical_flow_follows_halfway() {
+        let mut shifts = vec![[0, 0]; 20];
+        shifts.push([16, 8]);
+        let Some([made, previous, current]) = interpolate(100, &shifts, Mat4::IDENTITY, [8, 4])
+        else {
+            return;
+        };
+        // Where the still camera's two colours happen to be the same primary (a third of
+        // the pixels), FSR keeps the game's vectors.
+        assert!(
+            made * 3.0 < previous.min(current),
+            "{made} against {previous} and {current}"
+        );
+    }
+
+    /// The camera turning: the game's motion vectors put the made frame halfway.
+    #[test]
+    fn moves_the_view_halfway_with_the_camera() {
+        let size = [512.0, 288.0];
+        // What is at a pixel now was 16 pixels to its right last frame.
+        let reproject = Mat4::from_translation(glam::Vec3::new(32.0 / size[0], 0.0, 0.0));
+        let shifts = [[0, 0], [-16, 0], [-32, 0], [-48, 0]];
+        let Some([made, previous, current]) = interpolate(1, &shifts, reproject, [-40, 0]) else {
+            return;
+        };
+        assert!(
+            made * 4.0 < previous.min(current),
+            "{made} against {previous} and {current}"
+        );
+    }
+}
@@ -0,0 +1,803 @@
+// This file is part of the FidelityFX SDK.
+//
+// Copyright (C) 2024 Advanced Micro Devices, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files(the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+// FidelityFX SDK 1.1.4's frame interpolation (ffx_frameinterpolation_*.h), ported to WGSL
+// for Horizon, for an SDR back buffer, inverted finite depth, the whole screen as the
+// interpolation rect and no distortion field. What differs from AMD's (interpolation.rs
+// lists why):
+// - the motion vectors come from the depth and the camera (`prepare`), already unjittered;
+// - the vector fields and reconstructed depths are storage buffers of atomics;
+// - both inpainting pyramids are a pass per level, and textures of their own;
+// - the interpolation writes one texture and the inpainting another (rgba16float can't
+//   be read_write everywhere);
+// - NaNs AMD's hardware turns into 0 (max(0, NaN)) are avoided up front.
+
+struct Params {
+    // This frame's unjittered clip space to the previous frame's.
+    reproject: mat4x4<f32>,
+    device_to_view: vec4<f32>,
+    render_size: vec2<i32>,
+    display_size: vec2<i32>,
+    // FSR's jitterOffset: render pixels.
+    jitter: vec2<f32>,
+    optical_flow_scale: vec2<f32>,
+    // GetOpticalFlowSize2.
+    optical_flow_size: vec2<i32>,
+    reset: u32,
+    tan_half_fov: f32,
+    // A mip level's size, for the pyramid passes.
+    level_size: vec2<i32>,
+    _pad: vec2<u32>,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var linear_clamp: sampler;
+@group(0) @binding(2) var input_depth: texture_depth_2d;
+@group(0) @binding(3) var current_color: texture_2d<f32>;
+@group(0) @binding(4) var previous_color: texture_2d<f32>;
+@group(0) @binding(5) var dilated_depth_out: texture_storage_2d<r32float, write>;
+@group(0) @binding(6) var dilated_mv_out: texture_storage_2d<rg32float, write>;
+@group(0) @binding(7) var dilated_depth: texture_2d<f32>;
+@group(0) @binding(8) var dilated_mv: texture_2d<f32>;
+@group(0) @binding(9) var<storage, read_write> rec_prev_depth: array<atomic<u32>>;
+@group(0) @binding(10) var<storage, read_write> rec_interp_depth: array<atomic<u32>>;
+@group(0) @binding(11) var<storage, read> rec_prev_depth_in: array<u32>;
+@group(0) @binding(12) var<storage, read> rec_interp_depth_in: array<u32>;
+@group(0) @binding(13) var<storage, read_write> game_field_x: array<atomic<u32>>;
+@group(0) @binding(14) var<storage, read_write> game_field_y: array<atomic<u32>>;
+@group(0) @binding(15) var<storage, read> game_field_x_in: array<u32>;
+@group(0) @binding(16) var<storage, read> game_field_y_in: array<u32>;
+@group(0) @binding(17) var<storage, read_write> of_field_x: array<atomic<u32>>;
+@group(0) @binding(18) var<storage, read_write> of_field_y: array<atomic<u32>>;
+@group(0) @binding(19) var<storage, read> of_field_x_in: array<u32>;
+@group(0) @binding(20) var<storage, read> of_field_y_in: array<u32>;
+@group(0) @binding(21) var optical_flow: texture_2d<i32>;
+@group(0) @binding(22) var<storage, read> scene_change: array<u32, 3>;
+@group(0) @binding(23) var<storage, read_write> counters: array<u32, 2>;
+@group(0) @binding(24) var<storage, read> counters_in: array<u32, 2>;
+// A pyramid's previous level, and the level a pyramid pass writes.
+@group(0) @binding(25) var pyramid_in: texture_2d<f32>;
+@group(0) @binding(26) var pyramid_out: texture_storage_2d<rgba16float, write>;
+// The whole game vector field and inpainting pyramids.
+@group(0) @binding(27) var game_pyramid: texture_2d<f32>;
+@group(0) @binding(28) var inpainting_pyramid: texture_2d<f32>;
+@group(0) @binding(29) var disocclusion_out: texture_storage_2d<rgba8unorm, write>;
+@group(0) @binding(30) var disocclusion: texture_2d<f32>;
+@group(0) @binding(31) var interpolated_out: texture_storage_2d<rgba16float, write>;
+@group(0) @binding(32) var interpolated: texture_2d<f32>;
+@group(0) @binding(33) var output: texture_storage_2d<rgba16float, write>;
+
+const EPSILON: f32 = 1e-03;
+const RECONSTRUCTED_DEPTH_WEIGHT_THRESHOLD: f32 = EPSILON;
+const COUNTER_FRAME_INDEX_SINCE_LAST_RESET: u32 = 1u;
+
+fn render_index(p: vec2<i32>) -> u32 {
+    return u32(p.y * params.render_size.x + p.x);
+}
+
+fn is_on_screen(p: vec2<i32>, size: vec2<i32>) -> bool {
+    return all(vec2<u32>(p) < vec2<u32>(size));
+}
+
+fn is_uv_inside(uv: vec2<f32>) -> bool {
+    return uv.x > 0.0 && uv.x < 1.0 && uv.y > 0.0 && uv.y < 1.0;
+}
+
+fn min_divided_by_max(v0: f32, v1: f32) -> f32 {
+    let m = max(v0, v1);
+    return select(0.0, min(v0, v1) / m, m != 0.0);
+}
+
+fn normalized_dot3(v0: vec3<f32>, v1: vec3<f32>) -> f32 {
+    let m = max(length(v0), length(v1));
+    return select(1.0, dot(v0 / m, v1 / m), m > 0.0);
+}
+
+fn linear_from_srgb(c: vec3<f32>) -> vec3<f32> {
+    return select(pow(c / 1.055 + 0.055 / 1.055, vec3(2.4)), c / 12.92, c < vec3(0.04045));
+}
+
+fn raw_rgb_to_luminance(c: vec3<f32>) -> f32 {
+    return dot(linear_from_srgb(c), vec3(0.2126, 0.7152, 0.0722));
+}
+
+struct Bilinear {
+    base: vec2<i32>,
+    weights: vec4<f32>,
+};
+
+fn bilinear(uv: vec2<f32>, size: vec2<i32>) -> Bilinear {
+    let px = uv * vec2<f32>(size) - 0.5;
+    let f = fract(px);
+    var b: Bilinear;
+    b.base = vec2<i32>(floor(px));
+    b.weights = vec4(
+        (1.0 - f.x) * (1.0 - f.y),
+        f.x * (1.0 - f.y),
+        (1.0 - f.x) * f.y,
+        f.x * f.y,
+    );
+    return b;
+}
+
+fn bilinear_offset(i: i32) -> vec2<i32> {
+    return vec2(i & 1, i >> 1u);
+}
+
+fn device_to_view_depth(d: f32) -> f32 {
+    return params.device_to_view.y / (d - params.device_to_view.x);
+}
+
+fn view_space_position(px: vec2<i32>, size: vec2<i32>, d: f32) -> vec3<f32> {
+    let z = device_to_view_depth(d);
+    let ndc = vec2<f32>(px) / vec2<f32>(size) * vec2(2.0, -2.0) + vec2(-1.0, 1.0);
+    return vec3(params.device_to_view.z * ndc.x * z, params.device_to_view.w * ndc.y * z, z);
+}
+
+// MOTION VECTOR FIELD (ffx_frameinterpolation_common.h)
+const PRIMARY_VECTOR_BIT: u32 = 0x80000000u;
+const PRIORITY_LOW_MAX: u32 = 31u;
+const PRIORITY_HIGH_MAX: u32 = 1023u;
+const PRIORITY_LOW_OFFSET: u32 = 16u;
+const PRIORITY_HIGH_OFFSET: u32 = 21u;
+
+struct VectorFieldEntry {
+    motion_vector: vec2<f32>,
+    high_priority: f32,
+    low_priority: f32,
+    valid: bool,
+    primary: bool,
+    secondary: bool,
+    in_painted: bool,
+    velocity: f32,
+    neg_outside: bool,
+    pos_outside: bool,
+};
+
+fn new_entry() -> VectorFieldEntry {
+    return VectorFieldEntry(vec2(0.0), 0.0, 0.0, false, false, false, false, 0.0, false, false);
+}
+
+fn is_primary(packed: u32) -> bool {
+    return (packed & PRIMARY_VECTOR_BIT) != 0u;
+}
+
+// ffxF32ToF16 and its inverse in integer arithmetic: pack2x16float needs a capability
+// some GPUs lack.
+fn f32_to_f16(v: f32) -> u32 {
+    let x = bitcast<u32>(v);
+    let sign = (x >> 16u) & 0x8000u;
+    let e = i32((x >> 23u) & 0xffu) - 112;
+    let m = x & 0x7fffffu;
+    if e >= 31 {
+        return sign | 0x7c00u;
+    }
+    if e <= 0 {
+        if e < -10 {
+            return sign;
+        }
+        let full = m | 0x800000u;
+        let shift = u32(14 - e);
+        return sign | ((full >> shift) + ((full >> (shift - 1u)) & 1u));
+    }
+    return sign | (((u32(e) << 10u) | (m >> 13u)) + ((m >> 12u) & 1u));
+}
+
+fn f16_to_f32(h: u32) -> f32 {
+    let sign = (h & 0x8000u) << 16u;
+    let e = (h >> 10u) & 0x1fu;
+    let m = h & 0x3ffu;
+    if e == 0u {
+        let v = f32(m) * (1.0 / 16777216.0);
+        return select(v, -v, sign != 0u);
+    }
+    if e == 31u {
+        return bitcast<f32>(sign | 0x7f800000u);
+    }
+    return bitcast<f32>(sign | ((e + 112u) << 23u) | (m << 13u));
+}
+
+fn pack_entries(primary: bool, high: u32, low: u32, mv: vec2<f32>) -> vec2<u32> {
+    let priority = select(0u, PRIMARY_VECTOR_BIT, primary)
+        | ((high & PRIORITY_HIGH_MAX) << PRIORITY_HIGH_OFFSET)
+        | ((low & PRIORITY_LOW_MAX) << PRIORITY_LOW_OFFSET);
+    return vec2(priority | f32_to_f16(mv.x), priority | f32_to_f16(mv.y));
+}
+
+fn unpack_entries(packed: vec2<u32>) -> VectorFieldEntry {
+    var e = new_entry();
+    e.high_priority = f32((packed.x >> PRIORITY_HIGH_OFFSET) & PRIORITY_HIGH_MAX) / f32(PRIORITY_HIGH_MAX);
+    e.low_priority = f32((packed.x >> PRIORITY_LOW_OFFSET) & PRIORITY_LOW_MAX) / f32(PRIORITY_LOW_MAX);
+    e.primary = is_primary(packed.x);
+    e.valid = e.high_priority > 0.0;
+    e.secondary = e.valid && !e.primary;
+    if e.secondary {
+        e.high_priority = 1.0 - e.high_priority;
+    }
+    e.motion_vector = vec2(f16_to_f32(packed.x & 0xffffu), f16_to_f32(packed.y & 0xffffu));
+    return e;
+}
+
+fn load_game_field(p: vec2<i32>) -> vec2<u32> {
+    if !is_on_screen(p, params.render_size) {
+        return vec2(0u);
+    }
+    let i = render_index(p);
+    return vec2(game_field_x_in[i], game_field_y_in[i]);
+}
+
+fn compute_mv_inpainting_level(uv: vec2<f32>, level: i32, size: vec2<i32>) -> vec4<f32> {
+    let b = bilinear(uv, size);
+    var sum = 0.0;
+    var color = vec4(0.0);
+    for (var i = 0; i < 4; i++) {
+        let p = b.base + bilinear_offset(i);
+        if is_on_screen(p, size) {
+            let s = textureLoad(game_pyramid, p, level);
+            let weight = b.weights[i] * f32(s.z > 0.0) * s.z;
+            sum += weight;
+            color += s * weight;
+        }
+    }
+    return color / select(1.0, sum, sum > 0.0);
+}
+
+fn load_inpainted_game_field_mv(uv: vec2<f32>) -> VectorFieldEntry {
+    let px = vec2<i32>(uv * vec2<f32>(params.render_size));
+    var e = unpack_entries(load_game_field(px));
+    if !e.valid {
+        var size = params.render_size;
+        var v = vec4(0.0);
+        let levels = i32(textureNumLevels(game_pyramid));
+        for (var level = 0; level < min(11, levels) && v.w == 0.0; level++) {
+            size /= 2;
+            v = compute_mv_inpainting_level(uv, level, size);
+        }
+        e.motion_vector = v.xy;
+        e.high_priority = v.z;
+        e.low_priority = v.w;
+        e.in_painted = true;
+    }
+    e.neg_outside = !is_uv_inside(uv - e.motion_vector);
+    e.pos_outside = !is_uv_inside(uv + e.motion_vector);
+    e.velocity = length(e.motion_vector);
+    return e;
+}
+
+fn sample_optical_flow_field(uv: vec2<f32>) -> VectorFieldEntry {
+    let size = params.optical_flow_size;
+    let b = bilinear(uv, size);
+    var e = new_entry();
+    var weight_sum = 0.0;
+    for (var i = 0; i < 4; i++) {
+        let p = b.base + bilinear_offset(i);
+        if is_on_screen(p, size) {
+            let w = b.weights[i];
+            let j = render_index(p);
+            let s = unpack_entries(vec2(of_field_x_in[j], of_field_y_in[j]));
+            e.motion_vector += s.motion_vector * w;
+            e.high_priority += s.high_priority * w;
+            e.low_priority += s.low_priority * w;
+            weight_sum += w;
+        }
+    }
+    if weight_sum > 0.0 {
+        e.motion_vector /= weight_sum;
+        e.high_priority /= weight_sum;
+        e.low_priority /= weight_sum;
+    }
+    e.neg_outside = !is_uv_inside(uv - e.motion_vector);
+    e.pos_outside = !is_uv_inside(uv + e.motion_vector);
+    e.velocity = length(e.motion_vector);
+    return e;
+}
+
+fn has_scene_changed() -> bool {
+    return (scene_change[1] & 0xfu) != 0u;
+}
+
+// ffx_frameinterpolation_reconstruct_dilated_velocity_and_previous_depth.h, with the
+// motion vectors computed from the depth and the camera.
+fn camera_motion_vector(p: vec2<i32>, depth: f32) -> vec2<f32> {
+    let size = vec2<f32>(params.render_size);
+    let uv = (vec2<f32>(p) + 0.5) / size - params.jitter / size;
+    let ndc = vec2(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0);
+    let previous = params.reproject * vec4(ndc, depth, 1.0);
+    let previous_uv = vec2(0.5, -0.5) * previous.xy / previous.w + 0.5;
+    return previous_uv - uv;
+}
+
+fn load_input_depth(p: vec2<i32>) -> f32 {
+    if !is_on_screen(p, params.render_size) {
+        return 0.0;
+    }
+    return textureLoad(input_depth, p, 0);
+}
+
+@compute @workgroup_size(8, 8)
+fn prepare_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let p = vec2<i32>(gid.xy);
+    if !is_on_screen(p, params.render_size) {
+        return;
+    }
+    let offsets = array(
+        vec2(0, 0), vec2(1, 0), vec2(0, 1), vec2(0, -1), vec2(-1, 0),
+        vec2(-1, 1), vec2(1, 1), vec2(-1, -1), vec2(1, -1),
+    );
+    var nearest = load_input_depth(p);
+    var nearest_coord = p;
+    for (var i = 1; i < 9; i++) {
+        let q = p + offsets[i];
+        if is_on_screen(q, params.render_size) {
+            let d = load_input_depth(q);
+            if d > nearest {
+                nearest_coord = q;
+                nearest = d;
+            }
+        }
+    }
+    let mv = camera_motion_vector(nearest_coord, load_input_depth(nearest_coord));
+    textureStore(dilated_depth_out, p, vec4(nearest, 0.0, 0.0, 0.0));
+    textureStore(dilated_mv_out, p, vec4(mv, 0.0, 0.0));
+    // ReconstructPrevDepth
+    let moving = mv * f32(length(mv * vec2<f32>(params.display_size)) > 0.1);
+    let uv = (vec2<f32>(p) + 0.5) / vec2<f32>(params.render_size);
+    let b = bilinear(uv + moving, params.render_size);
+    for (var i = 0; i < 4; i++) {
+        if b.weights[i] > RECONSTRUCTED_DEPTH_WEIGHT_THRESHOLD {
+            let q = b.base + bilinear_offset(i);
+            if is_on_screen(q, params.render_size) {
+                atomicMax(&rec_prev_depth[render_index(q)], bitcast<u32>(nearest));
+            }
+        }
+    }
+}
+
+// ffx_frameinterpolation_setup.h: the frames since the last reset (the vector fields are
+// cleared by the encoder).
+@compute @workgroup_size(1)
+fn setup_pass() {
+    if params.reset != 0u || has_scene_changed() {
+        counters[COUNTER_FRAME_INDEX_SINCE_LAST_RESET] = 0u;
+    } else {
+        counters[COUNTER_FRAME_INDEX_SINCE_LAST_RESET] += 1u;
+    }
+}
+
+// ffx_frameinterpolation_reconstruct_previous_depth.h: the interpolated frame's depth.
+@compute @workgroup_size(8, 8)
+fn reconstruct_previous_depth_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let p = vec2<i32>(gid.xy);
+    if !is_on_screen(p, params.render_size) {
+        return;
+    }
+    let mv = textureLoad(dilated_mv, p, 0).xy * 0.5;
+    let depth = textureLoad(dilated_depth, p, 0).x;
+    let uv = (vec2<f32>(p) + 0.5) / vec2<f32>(params.render_size);
+    let b = bilinear(uv + mv, params.render_size);
+    for (var i = 0; i < 4; i++) {
+        let q = b.base + bilinear_offset(i);
+        if b.weights[i] > RECONSTRUCTED_DEPTH_WEIGHT_THRESHOLD && is_on_screen(q, params.render_size) {
+            atomicMax(&rec_interp_depth[render_index(q)], bitcast<u32>(depth));
+        }
+    }
+}
+
+// ffx_frameinterpolation_game_motion_vector_field.h
+fn priority_from_view_depth(view_depth_in: f32) -> u32 {
+    let d = pow(view_depth_in, 0.33);
+    let factor = u32((1.0 - d * (1.0 / (1.0 + d))) * f32(PRIORITY_HIGH_MAX));
+    return max(1u, factor);
+}
+
+fn update_game_field(p: vec2<i32>, packed: vec2<u32>) -> u32 {
+    let i = render_index(p);
+    let x = atomicMax(&game_field_x[i], packed.x);
+    let y = atomicMax(&game_field_y[i], packed.y);
+    return max(x, y);
+}
+
+@compute @workgroup_size(8, 8)
+fn game_motion_vector_field_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let p = vec2<i32>(gid.xy);
+    if !is_on_screen(p, params.render_size) {
+        return;
+    }
+    let size = vec2<f32>(params.render_size);
+    let uv = (vec2<f32>(p) + 0.5) / size;
+    let depth = textureLoad(dilated_depth, p, 0).x;
+    let mv = textureLoad(dilated_mv, p, 0).xy;
+    let half_mv = mv * 0.5;
+    let interpolated_uv = uv + half_mv;
+    let high_primary = priority_from_view_depth(device_to_view_depth(depth));
+    let previous = textureSampleLevel(previous_color, linear_clamp, uv + mv, 0.0).rgb;
+    let current = textureSampleLevel(current_color, linear_clamp, uv, 0.0).rgb;
+    let previous_luma = 0.001 + raw_rgb_to_luminance(previous);
+    let current_luma = 0.001 + raw_rgb_to_luminance(current);
+    var low = u32(round(min_divided_by_max(previous_luma, current_luma) * f32(PRIORITY_LOW_MAX)))
+        * u32(is_uv_inside(uv + mv));
+    let primary = pack_entries(true, high_primary, low, half_mv);
+    let b = bilinear(interpolated_uv, params.render_size);
+    for (var i = 0; i < 4; i++) {
+        let q = b.base + bilinear_offset(i);
+        if is_on_screen(q, params.render_size) {
+            update_game_field(q, primary);
+        }
+    }
+    if length(half_mv * size) > EPSILON {
+        var write_secondary = true;
+        var primary_hits = 0u;
+        let step_scale = length(1.0 / size);
+        let step_mv = normalize(mv);
+        let break_dist = min(length(half_mv), length(vec2(0.5, 0.5)));
+        for (var s = step_scale; s <= break_dist && write_secondary; s += step_scale) {
+            let secondary_uv = interpolated_uv - step_mv * s;
+            let sb = bilinear(secondary_uv, params.render_size);
+            let high_secondary = max(1u, PRIORITY_HIGH_MAX - high_primary);
+            let to_centre_raw = vec2(0.5, 0.5) - secondary_uv;
+            let to_centre = select(vec2(0.0), normalize(to_centre_raw), length(to_centre_raw) > 0.0);
+            low = u32(max(0.0, dot(to_centre, step_mv)) * f32(PRIORITY_LOW_MAX));
+            let secondary = pack_entries(false, high_secondary, low, half_mv);
+            let q = sb.base;
+            write_secondary = write_secondary && is_on_screen(q, params.render_size);
+            if write_secondary {
+                let existing = update_game_field(q, secondary);
+                primary_hits += u32(is_primary(existing));
+                write_secondary = write_secondary && primary_hits <= 3u;
+            }
+        }
+    }
+}
+
+// ffx_frameinterpolation_compute_game_vector_field_inpainting_pyramid.h: SPD, a level per
+// pass. Level 0 reads the field, the others the level above.
+fn reduce_game_field(v: array<vec4<f32>, 4>) -> vec4<f32> {
+    var sum = vec4(0.0);
+    var weight_sum = 0.0;
+    for (var i = 0; i < 4; i++) {
+        let w = f32(v[i].z > 0.0);
+        sum += v[i] * w;
+        weight_sum += w;
+    }
+    return sum / select(1.0, weight_sum, weight_sum > EPSILON);
+}
+
+@compute @workgroup_size(8, 8)
+fn game_field_pyramid_first_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let p = vec2<i32>(gid.xy);
+    if !is_on_screen(p, params.level_size) {
+        return;
+    }
+    var v: array<vec4<f32>, 4>;
+    for (var i = 0; i < 4; i++) {
+        let e = unpack_entries(load_game_field(p * 2 + bilinear_offset(i)));
+        v[i] = vec4(e.motion_vector, e.high_priority, e.low_priority);
+    }
+    textureStore(pyramid_out, p, reduce_game_field(v));
+}
+
+@compute @workgroup_size(8, 8)
+fn game_field_pyramid_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let p = vec2<i32>(gid.xy);
+    if !is_on_screen(p, params.level_size) {
+        return;
+    }
+    var v: array<vec4<f32>, 4>;
+    for (var i = 0; i < 4; i++) {
+        v[i] = textureLoad(pyramid_in, p * 2 + bilinear_offset(i), 0);
+    }
+    textureStore(pyramid_out, p, reduce_game_field(v));
+}
+
+// ffx_frameinterpolation_optical_flow_vector_field.h
+fn load_optical_flow(p: vec2<i32>) -> vec2<f32> {
+    let size = vec2<i32>(textureDimensions(optical_flow));
+    if !is_on_screen(p, size) {
+        return vec2(0.0);
+    }
+    return vec2<f32>(textureLoad(optical_flow, p, 0).xy) * params.optical_flow_scale;
+}
+
+@compute @workgroup_size(8, 8)
+fn optical_flow_vector_field_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let p = vec2<i32>(gid.xy);
+    let rect = vec2<f32>(params.display_size);
+    var avg = vec2(0.0);
+    var sw = 0.0;
+    for (var y = -1; y <= 1; y++) {
+        for (var x = -1; x <= 1; x++) {
+            let vs = load_optical_flow(p + vec2(x, y));
+            let len = length(vs * rect);
+            let w = max(0.0, 512.0 - len) * f32(len > 1.0);
+            avg += vs * w;
+            sw += w;
+        }
+    }
+    // AMD divides by 0 here, and its max(0, NaN) below gives 0 weights: a zero vector.
+    if sw > 0.0 {
+        avg /= sw;
+    }
+    var v = vec2(0.0);
+    sw = 0.0;
+    for (var y = -1; y <= 1; y++) {
+        for (var x = -1; x <= 1; x++) {
+            let vs = load_optical_flow(p + vec2(x, y));
+            let len = length(vs * rect);
+            let len_factor = max(0.0, 512.0 - len) * f32(len > 1.0);
+            let w = pow(max(0.0, dot(avg, vs)), 1.25) * len_factor;
+            v += vs * w;
+            sw += w;
+        }
+    }
+    if sw > EPSILON {
+        v /= sw;
+    }
+    // computeOpticalFlowFieldMvs
+    let uv = (vec2<f32>(p) + 0.5) / vec2<f32>(params.optical_flow_size);
+    let half_mv = v * 0.5;
+    let previous = textureSampleLevel(previous_color, linear_clamp, uv + v, 0.0).rgb;
+    let current = textureSampleLevel(current_color, linear_clamp, uv, 0.0).rgb;
+    let previous_luma = 0.001 + raw_rgb_to_luminance(previous);
+    let current_luma = 0.001 + raw_rgb_to_luminance(current);
+    let velocity = length(v * rect);
+    let high = u32(velocity > 1.0)
+        * u32(saturate(velocity / length(rect * 0.05)) * f32(PRIORITY_HIGH_MAX));
+    if high > 0u {
+        let low = u32(round(min_divided_by_max(previous_luma, current_luma) * f32(PRIORITY_LOW_MAX)))
+            * u32(is_uv_inside(uv + v));
+        let packed = pack_entries(true, high, low, half_mv);
+        let b = bilinear(uv + half_mv, params.optical_flow_size);
+        for (var i = 0; i < 4; i++) {
+            let q = b.base + bilinear_offset(i);
+            if is_on_screen(q, params.optical_flow_size) {
+                let j = render_index(q);
+                atomicMax(&of_field_x[j], packed.x);
+                atomicMax(&of_field_y[j], packed.y);
+            }
+        }
+    }
+}
+
+// ffx_frameinterpolation_disocclusion_mask.h
+fn load_estimated_depth(which: u32, p: vec2<i32>) -> f32 {
+    if which == 0u {
+        return bitcast<f32>(rec_prev_depth_in[render_index(p)]);
+    }
+    return textureLoad(dilated_depth, p, 0).x;
+}
+
+fn compute_depth_clip(which: u32, uv: vec2<f32>, current_depth: f32) -> f32 {
+    let current_view = device_to_view_depth(current_depth);
+    let b = bilinear(uv, params.render_size);
+    var depth = 0.0;
+    var weight_sum = 0.0;
+    for (var i = 0; i < 4; i++) {
+        let q = b.base + bilinear_offset(i);
+        let w = b.weights[i];
+        if is_on_screen(q, params.render_size) && w > RECONSTRUCTED_DEPTH_WEIGHT_THRESHOLD {
+            let previous_depth = load_estimated_depth(which, q);
+            let previous_view = device_to_view_depth(previous_depth);
+            let diff = current_view - previous_view;
+            if diff > 0.0 {
+                let plane_depth = min(previous_depth, current_depth);
+                let centre = view_space_position(params.render_size / 2, params.render_size, plane_depth);
+                let corner = view_space_position(vec2(0), params.render_size, plane_depth);
+                let half_viewport_width = length(vec2<f32>(params.render_size));
+                let threshold = min(current_view, previous_view);
+                let k_fov = length(corner) / length(centre);
+                let required = 1.37e-05 * k_fov * half_viewport_width * threshold;
+                depth += f32(required / diff >= 1.0) * w;
+                weight_sum += w;
+            }
+        }
+    }
+    return select(0.0, saturate(1.0 - depth / weight_sum), weight_sum > 0.0);
+}
+
+@compute @workgroup_size(8, 8)
+fn disocclusion_mask_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let p = vec2<i32>(gid.xy);
+    if !is_on_screen(p, params.render_size) {
+        return;
+    }
+    let depth = bitcast<f32>(rec_interp_depth_in[render_index(p)]);
+    let uv = (vec2<f32>(p) + 0.5) / vec2<f32>(params.render_size);
+    let game = load_inpainted_game_field_mv(uv);
+    var mask = vec2(
+        1.0 - compute_depth_clip(0u, uv + game.motion_vector, depth),
+        1.0 - compute_depth_clip(1u, uv - game.motion_vector, depth),
+    );
+    mask = vec2<f32>(mask >= vec2(EPSILON));
+    let source_mv = game.motion_vector * 2.0;
+    let size = vec2<f32>(params.render_size);
+    let previous = vec2<i32>((uv + source_mv) * size);
+    mask.x = saturate(mask.x + f32(!is_on_screen(previous, params.render_size)));
+    let current = vec2<i32>((uv - source_mv) * size);
+    mask.y = saturate(mask.y + f32(!is_on_screen(current, params.render_size)));
+    textureStore(disocclusion_out, p, vec4(mask, 0.0, 0.0));
+}
+
+// ffx_frameinterpolation.h
+struct SourceColor {
+    raw: vec3<f32>,
+    weight_sum: f32,
+};
+
+fn sample_bilinear(is_current: bool, uv: vec2<f32>, mv: vec2<f32>) -> SourceColor {
+    let size = params.display_size;
+    let b = bilinear(uv + mv, size);
+    var color = vec3(0.0);
+    var weight_sum = 0.0;
+    for (var i = 0; i < 4; i++) {
+        let q = b.base + bilinear_offset(i);
+        if is_on_screen(q, size) {
+            let w = b.weights[i];
+            if is_current {
+                color += textureLoad(current_color, q, 0).rgb * w;
+            } else {
+                color += textureLoad(previous_color, q, 0).rgb * w;
+            }
+            weight_sum += w;
+        }
+    }
+    return SourceColor(select(vec3(0.0), color / weight_sum, weight_sum != 0.0), weight_sum);
+}
+
+@compute @workgroup_size(8, 8)
+fn interpolate_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let p = vec2<i32>(gid.xy);
+    if !is_on_screen(p, params.display_size) {
+        return;
+    }
+    let frame_index = counters_in[COUNTER_FRAME_INDEX_SINCE_LAST_RESET];
+    if frame_index == 0u {
+        textureStore(interpolated_out, p, vec4(textureLoad(current_color, p, 0).rgb, 0.0));
+        return;
+    }
+    var in_painting = 0.0;
+    let uv = (vec2<f32>(p) + 0.5) / vec2<f32>(params.display_size);
+    let game = load_inpainted_game_field_mv(uv);
+    let flow = sample_optical_flow_field(uv);
+    var disocclusion_factor = vec2<f32>(
+        saturate(textureSampleLevel(disocclusion, linear_clamp, uv, 0.0).xy) == vec2(1.0),
+    );
+    let previous_game = sample_bilinear(false, uv, game.motion_vector);
+    let current_game = sample_bilinear(true, uv, -game.motion_vector);
+    let previous_of = sample_bilinear(false, uv, flow.motion_vector);
+    let current_of = sample_bilinear(true, uv, -flow.motion_vector);
+    disocclusion_factor.x *= f32(!game.pos_outside);
+    disocclusion_factor.y *= f32(!game.neg_outside);
+    in_painting = saturate(max(in_painting, f32(length(disocclusion_factor) <= EPSILON)));
+    var t = 0.5;
+    t += 0.5 * (1.0 - disocclusion_factor.x);
+    t -= 0.5 * (1.0 - disocclusion_factor.y);
+    var color = mix(previous_game.raw, current_game.raw, saturate(t));
+    let disoccluded = saturate(1.0 - min(disocclusion_factor.x, disocclusion_factor.y));
+    if previous_game.weight_sum == 0.0 {
+        color = current_game.raw;
+    } else if current_game.weight_sum == 0.0 {
+        color = previous_game.raw;
+    }
+    if previous_game.weight_sum == 0.0 && current_game.weight_sum == 0.0 {
+        in_painting = 1.0;
+    }
+    var of_t = 1.0;
+    if previous_of.weight_sum > 0.0 && current_of.weight_sum > 0.0 {
+        of_t = 0.5;
+    } else if previous_of.weight_sum > 0.0 {
+        of_t = 0.0;
+    }
+    let of_color = mix(previous_of.raw, current_of.raw, of_t);
+    let of_sim = normalized_dot3(previous_of.raw, current_of.raw);
+    var game_sim = normalized_dot3(previous_game.raw, current_game.raw);
+    game_sim = mix(max(EPSILON, game_sim), 1.0, disoccluded);
+    var game_bias = saturate(game_sim / max(EPSILON, of_sim));
+    game_bias = mix(game_bias, 1.0, f32(frame_index < 10u));
+    color = mix(of_color, color, saturate(game_bias));
+    textureStore(interpolated_out, p, vec4(color, in_painting));
+}
+
+// ffx_frameinterpolation_compute_inpainting_pyramid.h: SPD, a level per pass.
+fn reduce_inpainting(v: array<vec4<f32>, 4>) -> vec4<f32> {
+    let sum = v[0].w + v[1].w + v[2].w + v[3].w;
+    if sum == 0.0 {
+        return vec4(0.0);
+    }
+    return (v[0] * v[0].w + v[1] * v[1].w + v[2] * v[2].w + v[3] * v[3].w) / sum;
+}
+
+@compute @workgroup_size(8, 8)
+fn inpainting_pyramid_first_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let p = vec2<i32>(gid.xy);
+    if !is_on_screen(p, params.level_size) {
+        return;
+    }
+    var v: array<vec4<f32>, 4>;
+    for (var i = 0; i < 4; i++) {
+        let q = p * 2 + bilinear_offset(i);
+        var c = vec4(0.0);
+        if is_on_screen(q, params.display_size) {
+            c = textureLoad(interpolated, q, 0);
+            c.w = saturate(1.0 - c.w);
+        }
+        v[i] = c;
+    }
+    textureStore(pyramid_out, p, reduce_inpainting(v));
+}
+
+@compute @workgroup_size(8, 8)
+fn inpainting_pyramid_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let p = vec2<i32>(gid.xy);
+    if !is_on_screen(p, params.level_size) {
+        return;
+    }
+    var v: array<vec4<f32>, 4>;
+    for (var i = 0; i < 4; i++) {
+        v[i] = textureLoad(pyramid_in, p * 2 + bilinear_offset(i), 0);
+    }
+    textureStore(pyramid_out, p, reduce_inpainting(v));
+}
+
+// ffx_frameinterpolation_inpainting.h (no HUD-less source: Horizon draws its HUD over
+// the made frame itself).
+fn compute_inpainting_level(uv: vec2<f32>, level: i32, size: vec2<i32>) -> vec4<f32> {
+    let b = bilinear(uv, size);
+    var color = vec4(0.0);
+    for (var i = 0; i < 4; i++) {
+        let q = b.base + bilinear_offset(i);
+        if is_on_screen(q, size) {
+            let s = textureLoad(inpainting_pyramid, q, level);
+            let w = b.weights[i] * f32(s.w > 0.0);
+            color += vec4(s.rgb * w, w);
+        }
+    }
+    return color;
+}
+
+fn compute_inpainting(p: vec2<i32>) -> vec3<f32> {
+    let uv = (vec2<f32>(p) + 0.5) / vec2<f32>(params.display_size);
+    var color = vec4(0.0);
+    var size = params.display_size;
+    let levels = i32(textureNumLevels(inpainting_pyramid));
+    for (var level = 0; level < min(10, levels); level++) {
+        size /= 2;
+        let mip = compute_inpainting_level(uv, level, size);
+        if mip.w > 0.0 {
+            let weight = pow(1.0 - f32(level) / 10.0, 3.0) * mip.w;
+            color += vec4(mip.rgb / mip.w, 1.0) * weight;
+        }
+    }
+    return select(vec3(0.0), color.rgb / color.w, color.w > 0.0);
+}
+
+@compute @workgroup_size(8, 8)
+fn inpainting_pass(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let p = vec2<i32>(gid.xy);
+    if !is_on_screen(p, params.display_size) {
+        return;
+    }
+    var c = textureLoad(interpolated, p, 0);
+    if c.w > EPSILON {
+        c = vec4(mix(c.rgb, compute_inpainting(p), c.w), 1.0);
+    }
+    textureStore(output, p, c);
+}
@@ -91,9 +91,35 @@ pub const TIERS: [Tier; 4] = [
        full: 0.38,
    },
 ];
+/// Which pixels of a light source's sprite may shine (`hdr_stats.wgsl`), as a fraction of
+/// the way from its darkest to its brightest opaque pixel: `parts` for one whose bright parts
+/// shine (a torch's flame, not its handle), `whole` for one that shines all over
+/// (`mesher::WHOLE`). The tier windows still decide how much.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Masks {
+    pub parts: f32,
+    pub whole: f32,
+}
+pub const MASKS: Masks = Masks {
+    parts: 0.32,
+    whole: 0.0,
+};
+/// A step of HDR calibration (`crate::hdr_calibration`): its test picture is drawn in nits
+/// above the controls instead of the frame.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Calibration {
+    /// 1 black level, 2 peak brightness, 3 paper white.
+    pub step: u32,
+    /// The slider's value, in nits.
+    pub nits: f32,
+    /// Where the controls start, as a share of the height.
+    pub band: f32,
+}

 pub struct Hdr {
    layout: wgpu::BindGroupLayout,
+    /// Horizon's logo as a 1-bit mask, for calibration's test pictures.
+    logo: wgpu::TextureView,
    pipeline: wgpu::RenderPipeline,
    /// Zeroes the frame's alpha once the world is kept (`keep_world`): what draws after,
    /// the hand, HUD and menus, raises it, so HDR output knows where they cover the world.
@@ -120,10 +146,19 @@ pub struct Hdr {
    pub tiers: [Tier; 4],
    /// The HUD and menus' brightness, as a share of paper white (0.25..=1).
    pub ui: f32,
+    /// Which pixels of a light source shine (`Masks`).
+    pub masks: Masks,
+    /// Calibration's test picture while it runs.
+    pub calibration: Option<Calibration>,
 }

 impl Hdr {
-    pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat, output: Output) -> Self {
+    pub fn new(
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        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()),
@@ -143,6 +178,7 @@ impl Hdr {
            entries: &[
                texture(0),
                texture(1),
+                texture(3),
                wgpu::BindGroupLayoutEntry {
                    binding: 2,
                    visibility: wgpu::ShaderStages::FRAGMENT,
@@ -232,12 +268,13 @@ impl Hdr {
        let params = || {
            device.create_buffer(&wgpu::BufferDescriptor {
                label: Some("Horizon HDR parameters"),
-                size: 80,
+                size: 96,
                usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
                mapped_at_creation: false,
            })
        };
        Self {
+            logo: logo_mask(device, queue),
            layout,
            pipeline: pipeline_for(output.format()),
            clear_alpha,
@@ -254,6 +291,8 @@ impl Hdr {
            black: 0.0,
            tiers: TIERS,
            ui: 1.0,
+            masks: MASKS,
+            calibration: None,
        }
    }

@@ -298,6 +337,10 @@ impl Hdr {
                        binding: 2,
                        resource: self.params.as_entire_binding(),
                    },
+                    wgpu::BindGroupEntry {
+                        binding: 3,
+                        resource: wgpu::BindingResource::TextureView(&self.logo),
+                    },
                ],
            });
            self.targets = Some(Targets {
@@ -310,6 +353,16 @@ impl Hdr {
        self.targets.as_ref().unwrap().frame.clone()
    }

+    /// The peak the HDR metadata gives: while calibration's peak step runs, PQ's own
+    /// 10 000 nits, so a compositor that clips at the declared peak (KWin) lets the test
+    /// patch through as bright as the display goes and the logo under it shows.
+    pub fn declared_peak(&self) -> f32 {
+        match self.calibration {
+            Some(c) if c.step == 2 => 10_000.0,
+            _ => self.peak,
+        }
+    }
+
    /// Keeps the world as drawn so far, before the hand and HUD cover it, then zeroes the
    /// frame's alpha: the world's marks live on in the copy, and whatever draws from here
    /// on raises the alpha where it covers the world.
@@ -430,6 +483,10 @@ impl Hdr {
                    binding: 2,
                    resource: self.capture_params.as_entire_binding(),
                },
+                wgpu::BindGroupEntry {
+                    binding: 3,
+                    resource: wgpu::BindingResource::TextureView(&self.logo),
+                },
            ],
        });
        queue.write_buffer(
@@ -442,9 +499,10 @@ impl Hdr {
    }

    /// hdr.wgsl's `Params`.
-    fn params(&self, world: bool, pq: bool) -> [f32; 20] {
+    fn params(&self, world: bool, pq: bool) -> [f32; 24] {
        let paper = self.paper_white.max(1.0);
-        let mut params = [0.0; 20];
+        let c = self.calibration;
+        let mut params = [0.0; 24];
        params[..5].copy_from_slice(&[
            paper / 80.0,
            (self.peak / paper).max(1.0),
@@ -459,6 +517,9 @@ impl Hdr {
            params[12 + i] = t.start;
            params[16 + i] = t.full;
        }
+        params[20] = c.map_or(0.0, |c| c.step as f32);
+        params[21] = c.map_or(0.0, |c| c.nits);
+        params[22] = c.map_or(0.0, |c| c.band);
        params
    }

@@ -489,6 +550,47 @@ impl Hdr {
    }
 }

+/// Horizon's icon (horizon-theme) as a 1-bit mask: its white strokes, one colour with hard
+/// edges, are the logo; everything else is not.
+fn logo_mask(device: &wgpu::Device, queue: &wgpu::Queue) -> wgpu::TextureView {
+    use wgpu::util::DeviceExt;
+    let (w, h, rgba) =
+        crate::hud::decode_bytes(horizon_theme::ICON_PNG).unwrap_or((1, 1, vec![0; 4]));
+    let mask: Vec<u8> = rgba
+        .as_chunks::<4>()
+        .0
+        .iter()
+        .map(|p| {
+            if p[3] > 128 && p[..3].iter().all(|&c| c > 200) {
+                255
+            } else {
+                0
+            }
+        })
+        .collect();
+    device
+        .create_texture_with_data(
+            queue,
+            &wgpu::TextureDescriptor {
+                label: Some("Horizon HDR calibration logo"),
+                size: wgpu::Extent3d {
+                    width: w,
+                    height: h,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: wgpu::TextureFormat::R8Unorm,
+                usage: wgpu::TextureUsages::TEXTURE_BINDING,
+                view_formats: &[],
+            },
+            wgpu::util::TextureDataOrder::LayerMajor,
+            &mask,
+        )
+        .create_view(&Default::default())
+}
+
 #[cfg(test)]
 mod tests {
    use super::{Output, pick};
@@ -500,6 +602,7 @@ mod tests {
        for source in [
            include_str!("../hdr.wgsl"),
            include_str!("../terrain.wgsl"),
+            include_str!("../hdr_stats.wgsl"),
            &entity,
        ] {
            let module = naga::front::wgsl::parse_str(source).unwrap();
@@ -0,0 +1,158 @@
+//! HDR emission thresholds (`hdr_stats.wgsl`): for every block sprite, the brightness its
+//! pixels must reach to shine in HDR output, measured on the GPU from the sprite's own
+//! darkest and brightest opaque pixel when HDR output turns on. Until then (and with HDR
+//! off) the texture holds zeros: every pixel of a light source may shine, and hdr.wgsl's
+//! tier windows alone decide, as before.
+
+use super::hdr::Masks;
+
+pub struct EmissionStats {
+    /// One texel per sprite: x the layer in its array, y the array.
+    pub view: wgpu::TextureView,
+    layout: wgpu::BindGroupLayout,
+    pipeline: wgpu::RenderPipeline,
+    params: wgpu::Buffer,
+}
+
+impl EmissionStats {
+    pub fn new(device: &wgpu::Device, split: u32, arrays: u32) -> Self {
+        let texture = device.create_texture(&wgpu::TextureDescriptor {
+            label: Some("Horizon HDR emission thresholds"),
+            size: wgpu::Extent3d {
+                width: split,
+                height: arrays,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: wgpu::TextureFormat::Rgba8Unorm,
+            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT,
+            view_formats: &[],
+        });
+        let view = texture.create_view(&Default::default());
+        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Horizon HDR emission thresholds"),
+            source: wgpu::ShaderSource::Wgsl(include_str!("../hdr_stats.wgsl").into()),
+        });
+        let mut entries: Vec<_> = (0..super::SPRITE_ARRAYS)
+            .map(|binding| wgpu::BindGroupLayoutEntry {
+                binding,
+                visibility: wgpu::ShaderStages::FRAGMENT,
+                ty: wgpu::BindingType::Texture {
+                    sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                    view_dimension: wgpu::TextureViewDimension::D2Array,
+                    multisampled: false,
+                },
+                count: None,
+            })
+            .collect();
+        entries.push(wgpu::BindGroupLayoutEntry {
+            binding: super::SPRITE_ARRAYS,
+            visibility: wgpu::ShaderStages::FRAGMENT,
+            ty: wgpu::BindingType::Buffer {
+                ty: wgpu::BufferBindingType::Uniform,
+                has_dynamic_offset: false,
+                min_binding_size: None,
+            },
+            count: None,
+        });
+        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("Horizon HDR emission thresholds"),
+            entries: &entries,
+        });
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("Horizon HDR emission thresholds"),
+            bind_group_layouts: &[Some(&layout)],
+            ..Default::default()
+        });
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("Horizon HDR emission thresholds"),
+            layout: Some(&pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &shader,
+                entry_point: Some("vs_stats"),
+                compilation_options: Default::default(),
+                buffers: &[],
+            },
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            fragment: Some(wgpu::FragmentState {
+                module: &shader,
+                entry_point: Some("fs_stats"),
+                compilation_options: Default::default(),
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: wgpu::TextureFormat::Rgba8Unorm,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            multiview_mask: None,
+            cache: None,
+        });
+        let params = device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Horizon HDR emission threshold parameters"),
+            size: 16,
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        Self {
+            view,
+            layout,
+            pipeline,
+            params,
+        }
+    }
+
+    /// Measures every sprite of `sprites` (terrain.wgsl's arrays) at `masks`.
+    pub fn measure(
+        &self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        sprites: &[wgpu::TextureView],
+        masks: Masks,
+    ) {
+        let mut params = [0u8; 16];
+        params[..4].copy_from_slice(&masks.parts.to_le_bytes());
+        params[4..8].copy_from_slice(&masks.whole.to_le_bytes());
+        queue.write_buffer(&self.params, 0, &params);
+        let mut entries: Vec<_> = sprites
+            .iter()
+            .enumerate()
+            .map(|(binding, view)| wgpu::BindGroupEntry {
+                binding: binding as u32,
+                resource: wgpu::BindingResource::TextureView(view),
+            })
+            .collect();
+        entries.push(wgpu::BindGroupEntry {
+            binding: super::SPRITE_ARRAYS,
+            resource: self.params.as_entire_binding(),
+        });
+        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("Horizon HDR emission thresholds"),
+            layout: &self.layout,
+            entries: &entries,
+        });
+        let mut encoder = device.create_command_encoder(&Default::default());
+        {
+            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("Horizon HDR emission thresholds"),
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &self.view,
+                    depth_slice: None,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                ..Default::default()
+            });
+            pass.set_pipeline(&self.pipeline);
+            pass.set_bind_group(0, &group, &[]);
+            pass.draw(0..3, 0..1);
+        }
+        queue.submit([encoder.finish()]);
+    }
+}
@@ -83,7 +83,8 @@ fn geometry(seed: i64, uv: [f32; 2]) -> Vec<Vertex> {
                            normal: [0; 4],
                            pos: c,
                            uv,
-                            layer: 2,
+                            // HDR output: the bolt shines like the sun (entity.wgsl fs_hdr_mark).
+                            layer: 2 | u32::from(crate::mesher::VERY_BRIGHT) << 16,
                            color,
                            light: 240 | 240 << 8,

@@ -57,7 +57,8 @@ fn reference(seed: i64, at: [f64; 3], camera: DVec3, uv: [f32; 2]) -> Vec<Vertex
                                normal: [0; 4],
                                pos: (o + glam::Vec3::from_array(c)).to_array(),
                                uv,
-                                layer: 2,
+                                // The HDR tier lightning.rs adds; the geometry is vanilla's.
+                                layer: 2 | u32::from(crate::mesher::VERY_BRIGHT) << 16,
                                color,
                                light: 240 | 240 << 8,

@@ -96,21 +96,8 @@ struct Bounds {

 impl Bounds {
    fn mesh(mesh: &SectionMesh) -> Option<Self> {
-        let mut positions = mesh
-            .solid
-            .iter()
-            .chain(&mesh.translucent)
-            .map(|v| Vec3::from(v.pos));
-        let first = positions.next()?;
-        let mut bounds = Self {
-            min: first,
-            max: first,
-        };
-        for pos in positions {
-            bounds.min = bounds.min.min(pos);
-            bounds.max = bounds.max.max(pos);
-        }
-        Some(bounds)
+        let [min, max] = mesh.bounds?;
+        Some(Self { min, max })
    }

    /// In view: the plan alone decides which tiles are in range (a circle),
@@ -165,6 +152,10 @@ impl Tile {
            None => &mut self.mesh,
        }
    }
+    /// Both meshes it holds in the arena: its own and the stand-in, if any.
+    pub fn meshes_mut(&mut self) -> impl Iterator<Item = &mut SectionGpu> {
+        std::iter::once(&mut self.mesh).chain(self.previous.as_mut().map(|(mesh, _)| mesh))
+    }
    pub fn visible(
        &self,
        key: TileKey,
@@ -419,7 +410,8 @@ impl Renderer {
            let mesh = pending.meshes.remove(&key).expect("pending tile");
            let [x, _, z] = key.origin();
            let size = key.size();
-            let keep = around_new.contains(&key)
+            let keep = mesh.keep
+                || around_new.contains(&key)
                || taken.iter().any(|&(cx, cz)| {
                    (x..x + size).contains(&(cx * 16)) && (z..z + size).contains(&(cz * 16))
                });
@@ -511,6 +503,7 @@ mod tests {
        let mesh = SectionMesh {
            solid: vec![vertex([0.0, -64.0, 0.0]), vertex([1024.0, 100.0, 1024.0])],
            translucent: vec![vertex([512.0, 120.0, 512.0])],
+            bounds: Some([Vec3::new(0.0, -64.0, 0.0), Vec3::new(1024.0, 120.0, 1024.0)]),
            ..Default::default()
        };
        let bounds = Bounds::mesh(&mesh).unwrap();
@@ -28,6 +28,9 @@ struct HorizonMaterialOut {
    @location(5) position: vec3<f32>,
    @location(6) spherical: f32,
    @location(7) cylindrical: f32,
+    @location(8) @interpolate(flat) face: u32,
+    @location(9) @interpolate(flat) fluid_quad: u32,
+    @location(10) @interpolate(flat) emission: f32,
 }
 fn horizon_material_vertex(position: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<f32>,
    light: vec2<u32>, origin: vec3<f32>) -> HorizonMaterialOut {
@@ -45,6 +48,19 @@ fn horizon_material_vertex(position: vec3<f32>, uv: vec2<f32>, layer: u32, color
    out.position = pos;
    out.spherical = length(pos);
    out.cylindrical = max(length(pos.xz), abs(pos.y));
+    // The colour's alpha byte (mesher.rs's `fluid_face` and `emitting`): a fluid quad's
+    // high nibble is 8 + its face (0..5), every other quad keeps 0xF there; the low nibble
+    // is 15 minus the face's HDR tier. Every corner of a quad carries the same byte, so the
+    // interpolated value rounds back exactly.
+    let flags = u32(round(color.a * 255.0));
+    let high = flags >> 4u;
+    let fluid = high >= 8u && (high & 7u) < 6u;
+    out.face = select(0u, high & 7u, fluid);
+    out.fluid_quad = u32(fluid);
+    // The tier (0 none, 1 low, 2 incandescent, 3 bright, 4 very bright) as how strongly the
+    // face shines: a redstone torch 7/15, a torch 14/15, glowstone 1.
+    let tier = 15u - (flags & 15u);
+    out.emission = select(min(f32(tier) * 7.0 / 15.0, 1.0), 0.0, tier == 0u);
    return out;
 }
@vertex fn horizon_material_vs(
@@ -65,8 +81,13 @@ fn horizon_material_vertex(position: vec3<f32>, uv: vec2<f32>, layer: u32, color
 }
 fn horizon_material_color(in: HorizonMaterialOut, translucent: bool) -> vec4<f32> {
    let albedo = horizon_terrain_sprite(in.uv, in.layer & 0x7fffu);
+    // Water draws translucent and lava solid, so the pass resolves the fluid kind.
+    let fluid = select(0u, select(2u, 1u, translucent), in.fluid_quad != 0u);
+    let normal = horizon_material_normal(in.position);
+    let tangent = horizon_material_tangent(in.position, in.uv, normal);
    return material(MaterialInput(albedo, in.tint, in.light, in.lightmap, in.position, in.uv,
-        translucent)).color;
+        translucent, horizon_sprite_tags(in.layer & 0x7fffu), in.clip.xy / frame.resolution,
+        in.face, fluid, in.emission, normal, tangent)).color;
 }
@fragment fn horizon_material_fs_solid(in: HorizonMaterialOut) -> @location(0) vec4<f32> {
    let color = horizon_material_color(in, false);
@@ -91,6 +112,9 @@ pub struct TerrainShape<'a> {
    pub sprites: [f64; 2],
    /// The world target's colour format.
    pub format: wgpu::TextureFormat,
+    /// The pack's tags of each tagged sprite layer, as `(layer, bits)`
+    /// (`Manifest::sprite_tags`).
+    pub sprite_tags: &'a [(u32, u32)],
 }

 /// The pack's terrain pipelines: solid (with the cutout test) and translucent, for the
@@ -110,17 +134,34 @@ fn vanilla_terrain() -> String {
    )
 }

-/// The terrain shader for the pack's material stage `source`.
-fn shader_source(source: &str) -> String {
+/// `horizon_sprite_tags(layer)`: the bits of `MaterialInput.tags` of each sprite layer.
+fn sprite_tags(tags: &[(u32, u32)]) -> String {
+    let mut out = String::from("fn horizon_sprite_tags(layer: u32) -> u32 {\n    switch layer {\n");
+    let mut tags = tags.to_vec();
+    tags.sort_unstable_by_key(|&(layer, bits)| (bits, layer));
+    for group in tags.chunk_by(|a, b| a.1 == b.1) {
+        let layers: Vec<String> = group.iter().map(|(layer, _)| format!("{layer}u")).collect();
+        out += &format!(
+            "        case {}: {{ return {}u; }}\n",
+            layers.join(", "),
+            group[0].1
+        );
+    }
+    out + "        default: { return 0u; }\n    }\n}\n"
+}
+
+/// The terrain shader for the pack's material stage `source`, with its sprite `tags`.
+fn shader_source(source: &str, tags: &[(u32, u32)]) -> String {
    format!(
-        "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{ENTRIES}",
-        vanilla_terrain()
+        "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{}{ENTRIES}",
+        vanilla_terrain(),
+        sprite_tags(tags)
    )
 }

 /// The material's naga module, its errors in the stage's file.
-fn module(stage: &CheckedStage) -> Result<naga::Module, String> {
-    let text = shader_source(&stage.source);
+fn module(stage: &CheckedStage, tags: &[(u32, u32)]) -> Result<naga::Module, String> {
+    let text = shader_source(&stage.source, tags);
    naga::front::wgsl::parse_str(&text)
        .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))
 }
@@ -134,7 +175,7 @@ impl NativeMaterial {
        stage: &CheckedStage,
        constants: &[(String, f64)],
    ) -> Result<Self, String> {
-        let module = module(stage)?;
+        let module = module(stage, shape.sprite_tags)?;
        let mut constants = present_constants(&module, constants);
        let sprite_names = [
            "horizon_terrain_SPRITE_ARRAYS",
@@ -297,15 +338,22 @@ mod tests {
            fn apply_fog(c: vec4<f32>) -> vec4<f32> { return c * gain; }\n\
            fn material(input: MaterialInput) -> Surface {\n    \
                let lit = input.albedo * input.tint * vec4(input.lightmap, 1.0);\n    \
-                return Surface(apply_fog(sprite(lit)));\n}\n";
+                let t = vec2<i32>(input.screen * frame.resolution);\n    \
+                let behind = textureLoad(opaque_color, t, 0) * textureLoad(opaque_depth, t, 0);\n    \
+                let mirrored = textureSampleLevel(reflection, reflection_sampler, input.screen, 0.0);\n    \
+                let kind = f32(input.face + input.fluid) * input.emission * mirrored.a;\n    \
+                let frame_of = vec4(cross(input.normal, input.tangent.xyz) * input.tangent.w, kind);\n    \
+                return Surface(apply_fog(sprite(lit)) + (behind + frame_of) * 0.0);\n}\n";
        let stage = stage(own);
-        let module = module(&stage).unwrap();
+        let tags = [(7, 1), (3, 1), (9, 2)];
+        assert!(sprite_tags(&tags).contains("case 3u, 7u: { return 1u; }"));
+        let module = module(&stage, &tags).unwrap();
        let info = naga::valid::Validator::new(
            naga::valid::ValidationFlags::all(),
            naga::valid::Capabilities::all(),
        )
        .validate(&module)
-        .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&shader_source(&stage.source))));
+        .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&shader_source(&stage.source, &tags))));
        let entries: Vec<&str> = module
            .entry_points
            .iter()
@@ -29,7 +29,20 @@ impl NativePack {
        constants: &[(String, f64)],
    ) -> Result<(Self, Vec<String>), String> {
        let (globals, format) = (terrain.globals, terrain.format);
-        let frame = NativeFrame::new(device);
+        let mut frame = NativeFrame::new(device);
+        // The mirror is drawn for a material that reads it, while `[reflection] option` is on.
+        let option = report.reflection.as_ref().and_then(|r| r.option.as_ref());
+        frame.reflects = report
+            .stages
+            .iter()
+            .find(|s| s.kind == StageKind::Material)
+            .is_some_and(|s| s.reads("reflection"))
+            && option.is_none_or(|id| {
+                constants
+                    .iter()
+                    .find(|(k, _)| k == id)
+                    .is_none_or(|(_, v)| *v != 0.0)
+            });
        let (post, others): (Vec<_>, Vec<_>) = report
            .stages
            .into_iter()
@@ -24,20 +24,87 @@ pub struct NativePost {
    nearest: wgpu::Sampler,
    /// Two targets of the world's size, written in turn (none with a single pass).
    targets: Option<([u32; 2], [wgpu::TextureView; 2])>,
-    /// One bind group per pass, for these world views.
-    groups: Option<(WorldViews, Vec<wgpu::BindGroup>)>,
+    /// Last frame's input to the last pass (`history`, binding 8), made with the targets,
+    /// and a black 1×1 in its place before then.
+    history: Option<wgpu::Texture>,
+    history_blank: wgpu::Texture,
+    /// One bind group per pass, for these world views and either the valid history or black.
+    groups: Option<(WorldViews, bool, Vec<wgpu::BindGroup>)>,
+    /// Whether `history` contains the last frame's input to the last pass.
+    history_valid: bool,
    /// The screen's colour format, the world target's too.
    format: wgpu::TextureFormat,
 }

-/// The `frame` every stage of a pack reads (group 3, binding 0), written once a frame.
+/// The `frame` every stage of a pack reads (group 3, binding 0), written once a frame, and
+/// what the material stage reads besides.
 pub struct NativeFrame {
    pub(super) buffer: wgpu::Buffer,
-    /// Group 3 of the stages that read only the frame (the sky).
+    /// Group 3 of the sky and material stages.
    pub layout: wgpu::BindGroupLayout,
    pub group: wgpu::BindGroup,
+    /// The world's depth before translucent terrain (the material stage's `opaque_depth`,
+    /// binding 6), copied each frame.
+    pub opaque_depth: wgpu::Texture,
+    /// The world's colour before translucent terrain (`opaque_color`, binding 11), copied
+    /// with it; 1×1 while the world draws straight to the window.
+    pub opaque_color: wgpu::Texture,
+    /// The material stage's `reflection` (binding 1): this frame's water mirror, else
+    /// `blank`; and its sampler (binding 2).
+    reflection: wgpu::TextureView,
+    blank: wgpu::TextureView,
+    reflection_sampler: wgpu::Sampler,
+    /// Whether the pack's material reads `reflection` (`NativePack::new`): else no mirror
+    /// is drawn and `has_reflection` stays 0.
+    pub reflects: bool,
+    /// Last frame's view-projection, camera and time (`write`).
+    last: Option<([[f32; 4]; 4], glam::DVec3, std::time::Instant)>,
+    /// The eased eye light (block, sky) and being in water and lava (`write`); NaN until the
+    /// first frame sets them.
+    eye: [f32; 4],
+    /// A post stage must use black history after a long gap until it has rendered a frame.
+    history_reset: bool,
    start: std::time::Instant,
    frames: u32,
+    /// `frame.wetness`, and when it was last written.
+    wetness: (f32, Option<std::time::Instant>),
+}
+
+/// A depth texture of `size` the world's depth is copied into.
+fn depth_copy(device: &wgpu::Device, size: [u32; 2]) -> wgpu::Texture {
+    copy_target(
+        device,
+        "Native shader pack opaque depth",
+        size,
+        wgpu::TextureFormat::Depth32Float,
+    )
+}
+
+/// A colour texture of `size` and `format` the world's colour is copied into.
+fn color_copy(device: &wgpu::Device, size: [u32; 2], format: wgpu::TextureFormat) -> wgpu::Texture {
+    copy_target(device, "Native shader pack opaque colour", size, format)
+}
+
+fn copy_target(
+    device: &wgpu::Device,
+    label: &str,
+    size: [u32; 2],
+    format: wgpu::TextureFormat,
+) -> wgpu::Texture {
+    device.create_texture(&wgpu::TextureDescriptor {
+        label: Some(label),
+        size: wgpu::Extent3d {
+            width: size[0].max(1),
+            height: size[1].max(1),
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format,
+        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+        view_formats: &[],
+    })
 }

 /// The uniform `frame` at binding 0, read by `visibility`.
@@ -54,6 +121,24 @@ fn frame_entry(visibility: wgpu::ShaderStages) -> wgpu::BindGroupLayoutEntry {
    }
 }

+/// The size of the water mirror for a world of `size`: half of it.
+pub fn reflection_size(size: [u32; 2]) -> [u32; 2] {
+    size.map(|s| s.div_ceil(2).max(1))
+}
+
+/// Seconds between frames past which the last one is forgotten (`NativeFrame::write`).
+const MAX_FRAME_GAP: f32 = 0.5;
+
+/// `value` moved toward `target` over `dt` seconds by a half-life in seconds; a NaN `value`
+/// (the first frame) starts at `target`.
+fn eased(value: f32, target: f32, half_life: f32, dt: f32) -> f32 {
+    if value.is_nan() {
+        target
+    } else {
+        target + (value - target) * 0.5f32.powf(dt / half_life)
+    }
+}
+
 impl NativeFrame {
    pub fn new(device: &wgpu::Device) -> Self {
        let buffer = device.create_buffer(&wgpu::BufferDescriptor {
@@ -64,32 +149,202 @@ impl NativeFrame {
        });
        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
            label: Some("Native shader pack frame"),
-            entries: &[frame_entry(wgpu::ShaderStages::VERTEX_FRAGMENT)],
+            entries: &[
+                frame_entry(wgpu::ShaderStages::VERTEX_FRAGMENT),
+                texture_entry(1, wgpu::TextureSampleType::Float { filterable: true }),
+                sampler_entry(2),
+                texture_entry(6, wgpu::TextureSampleType::Depth),
+                texture_entry(11, wgpu::TextureSampleType::Float { filterable: false }),
+            ],
        });
-        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("Native shader pack frame"),
-            layout: &layout,
-            entries: &[wgpu::BindGroupEntry {
-                binding: 0,
-                resource: buffer.as_entire_binding(),
-            }],
+        let opaque_depth = depth_copy(device, [1, 1]);
+        let opaque_color = color_copy(device, [1, 1], wgpu::TextureFormat::Rgba8Unorm);
+        let blank = copy_target(
+            device,
+            "Native shader pack reflection blank",
+            [1, 1],
+            wgpu::TextureFormat::Rgba8Unorm,
+        )
+        .create_view(&Default::default());
+        let reflection_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            label: Some("Native shader pack reflection sampler"),
+            mag_filter: wgpu::FilterMode::Linear,
+            min_filter: wgpu::FilterMode::Linear,
+            ..Default::default()
        });
+        let group = Self::group(
+            device,
+            &layout,
+            &buffer,
+            (&blank, &reflection_sampler),
+            &opaque_depth,
+            &opaque_color,
+        );
        Self {
            buffer,
            layout,
            group,
+            opaque_depth,
+            opaque_color,
+            reflection: blank.clone(),
+            blank,
+            reflection_sampler,
+            reflects: false,
+            last: None,
+            eye: [f32::NAN; 4],
+            history_reset: true,
            start: std::time::Instant::now(),
            frames: 0,
+            wetness: (0.0, None),
        }
    }

+    fn group(
+        device: &wgpu::Device,
+        layout: &wgpu::BindGroupLayout,
+        buffer: &wgpu::Buffer,
+        (reflection, sampler): (&wgpu::TextureView, &wgpu::Sampler),
+        opaque_depth: &wgpu::Texture,
+        opaque_color: &wgpu::Texture,
+    ) -> wgpu::BindGroup {
+        device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("Native shader pack frame"),
+            layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: buffer.as_entire_binding(),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::TextureView(reflection),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 2,
+                    resource: wgpu::BindingResource::Sampler(sampler),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 6,
+                    resource: wgpu::BindingResource::TextureView(
+                        &opaque_depth.create_view(&Default::default()),
+                    ),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 11,
+                    resource: wgpu::BindingResource::TextureView(
+                        &opaque_color.create_view(&Default::default()),
+                    ),
+                },
+            ],
+        })
+    }
+
+    /// Keeps the opaque copies the size of the world's depth `depth` and, where the world's
+    /// colour `color` can be copied (the scaled target, not the window's own), its size and
+    /// format; the group is made again when they change.
+    pub fn fit_opaque(
+        &mut self,
+        device: &wgpu::Device,
+        depth: &wgpu::Texture,
+        color: Option<&wgpu::Texture>,
+    ) {
+        let size = [depth.width(), depth.height()];
+        let (color_size, format) = match color {
+            Some(c) => ([c.width(), c.height()], c.format()),
+            None => ([1, 1], self.opaque_color.format()),
+        };
+        let color_fits = [self.opaque_color.width(), self.opaque_color.height()] == color_size
+            && self.opaque_color.format() == format;
+        let depth_fits = [self.opaque_depth.width(), self.opaque_depth.height()] == size;
+        if depth_fits && color_fits {
+            return;
+        }
+        if !color_fits {
+            self.opaque_color = color_copy(device, color_size, format);
+        }
+        if !depth_fits {
+            self.opaque_depth = depth_copy(device, size);
+        }
+        self.regroup(device);
+    }
+
+    /// Binds `view` as this frame's `reflection` (`None`: the blank). The mirror is drawn
+    /// before the stages read it.
+    pub fn set_reflection(&mut self, device: &wgpu::Device, view: Option<&wgpu::TextureView>) {
+        let view = view.unwrap_or(&self.blank);
+        if *view != self.reflection {
+            self.reflection = view.clone();
+            self.regroup(device);
+        }
+    }
+
+    fn regroup(&mut self, device: &wgpu::Device) {
+        self.group = Self::group(
+            device,
+            &self.layout,
+            &self.buffer,
+            (&self.reflection, &self.reflection_sampler),
+            &self.opaque_depth,
+            &self.opaque_color,
+        );
+    }
+
    /// Writes this frame's inputs, for a world of `size`.
    pub fn write(&mut self, queue: &wgpu::Queue, frame: &Frame, size: [u32; 2]) {
        let seconds = self.start.elapsed().as_secs_f32() % 3600.0;
-        let inputs = frame_inputs(frame, size, seconds, self.frames);
+        let now = std::time::Instant::now();
+        let since = self.wetness.1.map_or(0.0, |t| (now - t).as_secs_f32());
+        self.wetness = (wetness(self.wetness.0, frame.pack.rain, since), Some(now));
+        let mut inputs = frame_inputs(frame, size, seconds, self.frames);
+        inputs.wetness = self.wetness.0;
+        if !self.reflects {
+            inputs.has_reflection = 0;
+        }
+        let view_proj = (Mat4::from_cols_array_2d(&inputs.projection)
+            * Mat4::from_cols_array_2d(&inputs.view))
+        .to_cols_array_2d();
+        inputs.previous_view_projection = view_proj;
+        // `write` skips title frames, so a gap means a pause or another world: the frame
+        // before says nothing about this one, and the eased values start over.
+        match self.last {
+            Some((previous, camera, time)) if (now - time).as_secs_f32() < MAX_FRAME_GAP => {
+                inputs.previous_view_projection = previous;
+                inputs.camera_motion = (frame.camera - camera).as_vec3().to_array();
+                inputs.delta_time = (now - time).as_secs_f32();
+            }
+            _ => {
+                self.eye = [f32::NAN; 4];
+                self.history_reset = true;
+            }
+        }
+        self.last = Some((view_proj, frame.camera, now));
+        // The eye's light and medium eased by half-lives in seconds, from where they are at
+        // first.
+        let targets = [
+            (inputs.eye_light[0], 2.0),
+            (inputs.eye_light[1], 2.0),
+            (f32::from(u8::from(inputs.eye_in == 1)), 0.25),
+            (f32::from(u8::from(inputs.eye_in == 2)), 0.25),
+        ];
+        let dt = inputs.delta_time;
+        for (value, (target, half_life)) in self.eye.iter_mut().zip(targets) {
+            *value = eased(*value, target, half_life, dt);
+        }
+        let [block, sky, water, lava] = self.eye;
+        inputs.eye_light_smooth = [block, sky];
+        inputs.in_water = water;
+        inputs.in_lava = lava;
        self.frames = self.frames.wrapping_add(1);
        queue.write_buffer(&self.buffer, 0, bytemuck::bytes_of(&inputs));
    }
+
+    /// Takes the post stage's pending history reset. It stays pending if post rendering is
+    /// skipped for a frame, so the first frame it does render still sees black history.
+    pub(super) fn take_history_reset(&mut self) -> bool {
+        let reset = self.history_reset;
+        self.history_reset = false;
+        reset
+    }
 }

 /// The option values of `constants` that `module` declares as overrides (wgpu refuses others).
@@ -151,6 +406,7 @@ impl NativePost {
                texture_entry(3, float),
                sampler_entry(4),
                sampler_entry(5),
+                texture_entry(8, float),
            ],
        });
        let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] = Default::default();
@@ -218,7 +474,10 @@ impl NativePost {
            linear: sampler("Native shader pack linear", wgpu::FilterMode::Linear),
            nearest: sampler("Native shader pack nearest", wgpu::FilterMode::Nearest),
            targets: None,
+            history: None,
+            history_blank: history_target(device, "Native shader pack history blank", [1, 1]),
            groups: None,
+            history_valid: false,
            format,
        })
    }
@@ -233,6 +492,7 @@ impl NativePost {
        device: &wgpu::Device,
        world: (&wgpu::TextureView, &wgpu::TextureView),
        size: [u32; 2],
+        history_reset: bool,
    ) {
        if self.passes.len() > 1 && self.targets.as_ref().is_none_or(|t| t.0 != size) {
            let target = |label| {
@@ -248,8 +508,10 @@ impl NativePost {
                        sample_count: 1,
                        dimension: wgpu::TextureDimension::D2,
                        format: INTERMEDIATE,
+                        // COPY_SRC: the last pass's input is kept as next frame's `history`.
                        usage: wgpu::TextureUsages::RENDER_ATTACHMENT
-                            | wgpu::TextureUsages::TEXTURE_BINDING,
+                            | wgpu::TextureUsages::TEXTURE_BINDING
+                            | wgpu::TextureUsages::COPY_SRC,
                        view_formats: &[],
                    })
                    .create_view(&Default::default())
@@ -261,15 +523,28 @@ impl NativePost {
                    target("Native shader pack B"),
                ],
            ));
+            self.history = Some(history_target(device, "Native shader pack history", size));
+            self.history_valid = false;
            self.groups = None;
        }
+        let blank_history = history_reset || !self.history_valid;
        if self
            .groups
            .as_ref()
-            .is_some_and(|((color, depth), _)| color == world.0 && depth == world.1)
+            .is_some_and(|((color, depth), blank, _)| {
+                color == world.0 && depth == world.1 && *blank == blank_history
+            })
        {
            return;
        }
+        let history = if blank_history {
+            &self.history_blank
+        } else {
+            self.history
+                .as_ref()
+                .expect("history exists after a post stage has more than one pass")
+        }
+        .create_view(&Default::default());
        let groups = (0..self.passes.len())
            .map(|i| {
                // Pass i reads what pass i - 1 wrote: target (i - 1) % 2, the world for the first.
@@ -305,11 +580,15 @@ impl NativePost {
                            binding: 5,
                            resource: wgpu::BindingResource::Sampler(&self.nearest),
                        },
+                        wgpu::BindGroupEntry {
+                            binding: 8,
+                            resource: wgpu::BindingResource::TextureView(&history),
+                        },
                    ],
                })
            })
            .collect();
-        self.groups = Some(((world.0.clone(), world.1.clone()), groups));
+        self.groups = Some(((world.0.clone(), world.1.clone()), blank_history, groups));
    }

    /// Runs the passes over the world target `world` (colour, depth) of `size`, the last onto
@@ -321,13 +600,14 @@ impl NativePost {
        world: (&wgpu::TextureView, &wgpu::TextureView),
        screen: &wgpu::TextureView,
        size: [u32; 2],
+        history_reset: bool,
        mut timing: Option<&mut super::pack_timing::PassTiming>,
    ) {
-        self.prepare(device, world, size);
+        self.prepare(device, world, size, history_reset);
        if let Some(t) = timing.as_deref_mut() {
            t.mark(device, encoder, (world.0, self.format));
        }
-        let Some((_, groups)) = &self.groups else {
+        let Some((_, _, groups)) = &self.groups else {
            return;
        };
        for (i, ((label, pipeline), group)) in self.passes.iter().zip(groups).enumerate() {
@@ -354,9 +634,47 @@ impl NativePost {
            pass.set_bind_group(GROUP, group, &[]);
            pass.draw(0..3, 0..1);
        }
+        // The last pass's input becomes next frame's `history`, once that pass has read this
+        // frame's.
+        let count = self.passes.len();
+        if count > 1
+            && let (Some(history), Some((_, targets))) = (&self.history, &self.targets)
+        {
+            encoder.copy_texture_to_texture(
+                targets[(count - 2) % 2].texture().as_image_copy(),
+                history.as_image_copy(),
+                history.size(),
+            );
+            self.history_valid = true;
+        }
    }
 }

+/// A target of `size` the post stage's `history` is copied into.
+fn history_target(device: &wgpu::Device, label: &str, size: [u32; 2]) -> wgpu::Texture {
+    device.create_texture(&wgpu::TextureDescriptor {
+        label: Some(label),
+        size: wgpu::Extent3d {
+            width: size[0].max(1),
+            height: size[1].max(1),
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: INTERMEDIATE,
+        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+        view_formats: &[],
+    })
+}
+
+/// `wetness` after `dt` seconds of `rain`: halfway there in 30 seconds while it rains
+/// harder, in 10 while it dries (the half-lives of the `shaders/` format's `wetness`).
+fn wetness(wetness: f32, rain: f32, dt: f32) -> f32 {
+    let half_life = if rain > wetness { 30.0 } else { 10.0 };
+    rain + (wetness - rain) * 0.5f32.powf(dt / half_life)
+}
+
 /// The frame as packs read it (docs/api/shaders-reference.md), from the renderer's `Frame`.
 pub fn frame_inputs(frame: &Frame, size: [u32; 2], seconds: f32, index: u32) -> FrameInputs {
    let aspect = size[0] as f32 / size[1].max(1) as f32;
@@ -416,14 +734,42 @@ pub fn frame_inputs(frame: &Frame, size: [u32; 2], seconds: f32, index: u32) ->
        },
        frame_index: index,
        hide_gui: u32::from(pack.hide_gui),
+        precipitation: pack.biome_precipitation.clamp(0, 2) as u32,
+        temperature: pack.temperature,
+        downfall: pack.rainfall,
+        wetness: pack.rain,
+        // Filled by `NativeFrame::write`, which remembers the frames before.
+        previous_view_projection: m(Mat4::IDENTITY),
+        camera_motion: [0.0; 3],
+        delta_time: 0.0,
+        eye_light_smooth: [level(pack.eye_light[0]), level(pack.eye_light[1])],
+        in_water: f32::from(u8::from(pack.eye_in as u32 == 1)),
+        in_lava: f32::from(u8::from(pack.eye_in as u32 == 2)),
+        water_plane: frame.water_plane.unwrap_or(0.0),
+        has_reflection: u32::from(frame.water_plane.is_some()),
+        reflection_resolution: reflection_size(size).map(|s| s as f32),
    }
 }

 #[cfg(test)]
 mod tests {
+    #[test]
+    fn eased_values_start_at_the_target_and_halve_the_distance() {
+        use super::eased;
+        assert_eq!(eased(f32::NAN, 0.25, 2.0, 0.0), 0.25);
+        assert_eq!(eased(1.0, 0.0, 2.0, 2.0), 0.5);
+        assert_eq!(eased(1.0, 0.0, 2.0, 0.0), 1.0);
+    }
    use super::*;
    use horizon_shader_api::{MANIFEST, Pack, check};

+    #[test]
+    fn wetness_rises_slower_than_it_dries() {
+        assert_eq!(wetness(0.0, 1.0, 30.0), 0.5);
+        assert_eq!(wetness(1.0, 0.0, 10.0), 0.5);
+        assert_eq!(wetness(0.25, 0.25, 5.0), 0.25);
+    }
+
    fn device() -> Option<(wgpu::Device, wgpu::Queue)> {
        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
@@ -521,7 +867,15 @@ mod tests {
            ..Default::default()
        });
        let view = screen.create_view(&Default::default());
-        post.run(&device, &mut encoder, (&color, &depth), &view, [4, 4], None);
+        post.run(
+            &device,
+            &mut encoder,
+            (&color, &depth),
+            &view,
+            [4, 4],
+            true,
+            None,
+        );
        let buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: None,
            size: u64::from(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT * 4),
@@ -552,4 +906,111 @@ mod tests {
            "{pixel:?}"
        );
    }
+
+    /// `history` is black on the first frame, then what the pass before the last wrote the
+    /// frame before.
+    #[test]
+    fn the_last_pass_reads_last_frames_input_as_history() {
+        let Some((device, queue)) = device() else {
+            return;
+        };
+        let manifest = "schema = 1
+id = \"t\"
+name = \"T\"
+version = \"1\"
+api = \"0.1\"
+            [[post]]
+file = \"a.wgsl\"
+[[post]]
+file = \"b.wgsl\"
+";
+        let a = "fn post(input: PostInput) -> vec4<f32> { return vec4<f32>(input.color.rgb * 0.5, 1.0); }
+";
+        let b = "fn post(input: PostInput) -> vec4<f32> { return textureLoad(history, vec2<i32>(input.pixel), 0); }
+";
+        let files = [(MANIFEST, manifest), ("a.wgsl", a), ("b.wgsl", b)]
+            .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec()))
+            .into();
+        let report = check(&Pack::from_files(files).unwrap()).unwrap();
+        let format = wgpu::TextureFormat::Rgba8Unorm;
+        let frame = NativeFrame::new(&device);
+        let mut post = NativePost::new(&device, report.stages, &[], format, &frame).unwrap();
+        let usage = wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;
+        let color = texture(&device, format, usage).create_view(&Default::default());
+        let depth = texture(&device, wgpu::TextureFormat::Depth32Float, usage)
+            .create_view(&Default::default());
+        let screen = texture(
+            &device,
+            format,
+            wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+        );
+        let view = screen.create_view(&Default::default());
+        let buffer = device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: u64::from(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT * 4),
+            usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        let mut frame_pixel = |history_reset| {
+            let mut encoder = device.create_command_encoder(&Default::default());
+            encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: None,
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &color,
+                    resolve_target: None,
+                    depth_slice: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color::WHITE),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                ..Default::default()
+            });
+            post.run(
+                &device,
+                &mut encoder,
+                (&color, &depth),
+                &view,
+                [4, 4],
+                history_reset,
+                None,
+            );
+            encoder.copy_texture_to_buffer(
+                screen.as_image_copy(),
+                wgpu::TexelCopyBufferInfo {
+                    buffer: &buffer,
+                    layout: wgpu::TexelCopyBufferLayout {
+                        offset: 0,
+                        bytes_per_row: Some(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT),
+                        rows_per_image: Some(4),
+                    },
+                },
+                screen.size(),
+            );
+            queue.submit([encoder.finish()]);
+            buffer
+                .slice(..)
+                .map_async(wgpu::MapMode::Read, |r| r.unwrap());
+            device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+            let pixel = buffer.slice(..).get_mapped_range().unwrap()[..4].to_vec();
+            buffer.unmap();
+            pixel
+        };
+        assert_eq!(
+            frame_pixel(true)[..3],
+            [0, 0, 0],
+            "black on the first frame"
+        );
+        let second = frame_pixel(false);
+        assert!(
+            second[..3].iter().all(|&v| v.abs_diff(128) <= 1),
+            "{second:?}"
+        );
+        assert_eq!(frame_pixel(true)[..3], [0, 0, 0], "black after a frame gap");
+        let fourth = frame_pixel(false);
+        assert!(
+            fourth[..3].iter().all(|&v| v.abs_diff(128) <= 1),
+            "{fourth:?}"
+        );
+    }
 }
@@ -0,0 +1,74 @@
+//! Render hook points for native mods (docs/native-mods.md): empty functions the renderer calls at
+//! fixed places of a frame, which a mod's mixins hook like those of
+//! `horizon-client/src/game/native_hooks.rs`, and listed with them in `native-hooks.json`. API
+//! 58.
+
+use super::Vertex;
+use super::pack_draw::EntitySpan;
+use glam::{DVec3, Mat4};
+
+/// What a mod can draw with once the world is drawn: after the sky, terrain, entities,
+/// particles, weather and the world post pass, before the first-person hand, the HUD and the
+/// screens. `color` holds the world's picture (copy it out before reading it: it is the target
+/// drawn into), `depth` the world's depth, reversed (0 is the sky).
+pub struct WorldDrawn<'a> {
+    pub device: &'a wgpu::Device,
+    pub queue: &'a wgpu::Queue,
+    pub encoder: &'a mut wgpu::CommandEncoder,
+    /// The frame's target and a view of it in `color_format`.
+    pub color: &'a wgpu::Texture,
+    pub color_view: &'a wgpu::TextureView,
+    pub color_format: wgpu::TextureFormat,
+    /// The size of `color`.
+    pub size: [u32; 2],
+    /// The world's depth (Depth32Float, sampleable), and its size: smaller than `size` when the
+    /// world draws at a lower resolution. It holds the frame's depth only when a mod asked for
+    /// it ([`RenderNeeds::world_depth`]) or something else kept it.
+    pub depth: &'a wgpu::TextureView,
+    pub depth_size: [u32; 2],
+    /// Camera-relative world to clip space, without TAA's jitter, and with it (what the world
+    /// was drawn with).
+    pub view_proj: Mat4,
+    pub jittered: Mat4,
+    /// The camera's position in the world.
+    pub camera: DVec3,
+    /// The camera-relative entity geometry of the frame (`Frame::entities`), quads of 4
+    /// vertices, and its runs by entity when a mod asked for them
+    /// ([`RenderNeeds::entity_spans`]) or a shader pack draws them.
+    pub entities: &'a [Vertex],
+    pub spans: &'a [EntitySpan],
+    /// The shared atlas entity UVs point into.
+    pub atlas: Option<&'a wgpu::Texture>,
+    /// Quad indices (0 1 2 0 2 3 for each 4 vertices), for as many quads as `entities` holds.
+    pub quad_indices: &'a wgpu::Buffer,
+}
+
+/// What the mods need from a frame that the game doesn't make for itself. Each mod sets what it
+/// needs and leaves the rest, so several can ask.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct RenderNeeds {
+    /// Record `Frame::entity_spans` without a shader pack: entity runs get a stable id from
+    /// their type's name, block entity runs their block state.
+    pub entity_spans: bool,
+    /// Keep the world pass's depth for [`native_world_drawn`] when nothing else does.
+    pub world_depth: bool,
+}
+
+/// The world is drawn (see [`WorldDrawn`]). Not called on the title screen's panorama.
+#[inline(never)]
+pub fn native_world_drawn(world: &mut WorldDrawn<'_>) {
+    let _ = world;
+}
+
+/// Asked as a frame is built and drawn: set what your mod needs.
+#[inline(never)]
+pub fn native_render_needs(needs: &mut RenderNeeds) {
+    let _ = needs;
+}
+
+/// What the mods need this frame ([`native_render_needs`]).
+pub fn render_needs() -> RenderNeeds {
+    let mut needs = RenderNeeds::default();
+    native_render_needs(&mut needs);
+    needs
+}
@@ -128,6 +128,9 @@ struct Graph {
    /// (`Node.sourceDirections`, as the faces rather than the steps); none for
    /// the camera's.
    entered: Vec<u8>,
+    /// Whether any section in the searched top layer was reached. Sections
+    /// above a clamped box use this conservative sky-band answer.
+    sky_reached: bool,
    /// Per section corner, during a full search: `SEES`, or how far the line
    /// from it towards the camera is known to stay in reached sections (the
    /// first sample that was not). Sections are only ever added during a
@@ -156,8 +159,22 @@ impl Graph {
        )
    }
    fn contains(&self, key: SectionKey) -> bool {
-        self.index(key)
-            .is_some_and(|i| self.directions[i] & REACHED != 0)
+        if let Some(i) = self.index(key) {
+            self.directions[i] & REACHED != 0
+        } else if (0..=self.sections).contains(&key.1)
+            && key.1 >= self.y0 + self.height
+            && (key.0 - self.from.0).abs() <= self.radius
+            && (key.2 - self.from.2).abs() <= self.radius
+        {
+            // Everything above the highest non-air section is open sky. A
+            // full search can reach that layer from a neighbouring column,
+            // so checking only this column's top cell can hide an upper
+            // section that is visible through the open layer. Once any top
+            // cell is reached, conservatively keep the whole sky band visible.
+            self.sky_reached
+        } else {
+            false
+        }
    }
    /// The full search from the camera (vanilla's `scheduleFullUpdate`).
    fn search(
@@ -174,13 +191,37 @@ impl Graph {
        self.min_y = columns.min_y;
        self.sections = columns.sections;
        self.y0 = -1;
-        self.height = columns.sections + 2;
+        if from.1 >= columns.sections {
+            self.height = columns.sections + 2;
+        } else {
+            let mut max_non_air_y = 0;
+            for dz in -radius..=radius {
+                for dx in -radius..=radius {
+                    let Some(column) = columns.map.get(&(from.0 + dx, from.2 + dz)) else {
+                        continue;
+                    };
+                    for (y, &v) in column.iter().enumerate().rev() {
+                        let y = y as i32;
+                        if y <= max_non_air_y {
+                            break;
+                        }
+                        if v != ALL_VISIBLE {
+                            max_non_air_y = y;
+                            break;
+                        }
+                    }
+                }
+            }
+            let top_y = max_non_air_y.max(from.1);
+            self.height = (top_y + 3).max(3).min(columns.sections + 2);
+        }
        let side = (2 * radius + 1) as usize;
        let size = side * side * self.height as usize;
        self.directions.clear();
        self.directions.resize(size, 0);
        self.entered.clear();
        self.entered.resize(size, 0);
+        self.sky_reached = false;
        self.rays.clear();
        self.rays
            .resize((side + 1) * (side + 1) * (self.height + 1) as usize, 0);
@@ -194,7 +235,8 @@ impl Graph {
                let base = self
                    .index((from.0 + dx, 0, from.2 + dz))
                    .expect("column inside the searched box");
-                vis[base..base + column.len()].copy_from_slice(column);
+                let len = (column.len() as i32).min(self.height - 1) as usize;
+                vis[base..base + len].copy_from_slice(&column[..len]);
            }
        }
        queue.clear();
@@ -279,6 +321,9 @@ impl Graph {
        while let Some(index) = queue.pop_front() {
            let i = index as usize;
            let key = self.key(i);
+            if key.1 == self.y0 + self.height - 1 {
+                self.sky_reached = true;
+            }
            let directions = self.directions[i];
            let entered = self.entered[i];
            let exits = if entered == 0 {
@@ -1082,6 +1127,64 @@ mod tests {
        );
    }

+    /// A clamped search may conservatively show sections above its searched
+    /// box, but it must never hide one that the full-height search reaches.
+    #[test]
+    fn vertical_clamping_only_adds_overdraw() {
+        let mut compared = 0;
+        let mut overdraw = 0;
+        let mut clamped = 0;
+        for seed in [0x9e37_79b9, 7, 0xdead_beef, 0x2545_f491] {
+            for (spread, count, radius) in [(6, 900, 6), (12, 2600, 12)] {
+                let mut o = Occlusion::new(0, 24);
+                random_world(&mut o, seed, count, spread);
+                let camera = at((0, 2, 0)) + DVec3::new(3.3, -5.7, 1.9);
+                o.settle(camera, radius);
+                let graph = o.graph.as_ref().expect("searched");
+                clamped += usize::from(graph.height < o.columns.sections + 2);
+                let full = reference(&o.columns, camera, radius, true);
+                let from = o.columns.section_of(camera);
+                let side = 2 * radius + 1;
+                let height = o.columns.sections + 2;
+                let full_contains = |key: SectionKey| {
+                    let (dx, dz, dy) = (key.0 - from.0, key.2 - from.2, key.1 + 1);
+                    if dx.abs() > radius || dz.abs() > radius || !(0..height).contains(&dy) {
+                        return false;
+                    }
+                    full[(((dz + radius) * side + dx + radius) * height + dy) as usize]
+                };
+                for x in from.0 - radius..=from.0 + radius {
+                    for z in from.2 - radius..=from.2 + radius {
+                        for y in -1..=o.columns.sections {
+                            let key = (x, y, z);
+                            let expected = full_contains(key);
+                            let actual = o.contains(key);
+                            compared += 1;
+                            assert!(
+                                !expected || actual,
+                                "clamped search hid {key:?} for seed {seed:#x}, spread {spread}, radius {radius}; from={from:?}, y0={}, height={}, expected={expected}, actual={actual}",
+                                graph.y0,
+                                graph.height
+                            );
+                            overdraw += usize::from(actual && !expected);
+                            if actual && !expected {
+                                assert!(
+                                    y >= graph.y0 + graph.height,
+                                    "overdraw must be above the clamped box: {key:?}, y0={}, height={}",
+                                    graph.y0,
+                                    graph.height
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        assert!(clamped > 0, "the comparison exercised a clamped search");
+        assert!(compared > 50_000, "compared {compared} sections");
+        assert!(overdraw > 0, "the conservative top-cell rule was exercised");
+    }
+
    /// A line checked again from the sample it failed at, after more
    /// sections were reached, ends where checking it from its corner does.
    #[test]
@@ -1226,4 +1329,26 @@ mod tests {
            assert_eq!(graph.entered, local.entered);
        }
    }
+
+    #[test]
+    fn vertical_clamping_bounds_height_and_reaches_open_sky() {
+        let mut o = Occlusion::new(0, 24);
+        o.set((0, 5, 0), 0); // Wall at section 5
+        o.settle(at((0, 2, 0)), 4);
+        let graph = o.graph.as_ref().expect("searched");
+        assert_eq!(graph.height, 5 + 3);
+        assert!(o.contains((0, 2, 0)), "camera section is reached");
+        assert!(o.contains((1, 20, 1)), "open air column is reached");
+
+        // An enclosed cave cannot reach the sky
+        let mut cave = Occlusion::new(0, 24);
+        for (dx, dy, dz) in STEPS {
+            cave.set((dx, 1 + dy, dz), 0);
+        }
+        cave.settle(at((0, 1, 0)), 4);
+        assert!(
+            !cave.contains((0, 10, 0)),
+            "enclosed cave does not see the sky"
+        );
+    }
 }
@@ -176,7 +176,7 @@ impl Features {
                &entity_module,
                entities,
                &entity_buffers,
-                kind("text", "entity", None, offset),
+                kind("text", "entity", Some(wgpu::Face::Back), offset),
            ),
            crumbling: set(
                &entity_module,
@@ -188,7 +188,12 @@ impl Features {
                &entity_module,
                entities,
                &entity_buffers,
-                kind("entity shadows", "shadow", None, shadow_bias),
+                kind(
+                    "entity shadows",
+                    "shadow",
+                    Some(wgpu::Face::Back),
+                    shadow_bias,
+                ),
            ),
            swirl: set(
                &entity_module,
@@ -113,6 +113,16 @@ impl PackAtlas {
    }
 }

+/// A `TerrainVertex` of flat draws' arena page (`hz_vertices`, six words each) into the vertex
+/// inputs, for vertex `hz_vertex_index`.
+pub const PULL: &str = "        uint hz_pw = hz_vertex_index * 6u;\n        \
+    hz_v_pos = uintBitsToFloat(uvec3(hz_vertices[hz_pw], hz_vertices[hz_pw + 1u], hz_vertices[hz_pw + 2u]));\n        \
+    hz_v_uv = uvec2(hz_vertices[hz_pw + 3u] & 65535u, hz_vertices[hz_pw + 3u] >> 16u);\n        \
+    hz_v_layer = hz_vertices[hz_pw + 4u] & 65535u;\n        \
+    uint hz_pl = hz_vertices[hz_pw + 4u] >> 16u;\n        \
+    hz_v_light = uvec2(hz_pl & 255u, hz_pl >> 8u);\n        \
+    hz_v_color = unpackUnorm4x8(hz_vertices[hz_pw + 5u]);\n";
+
 /// GLSL: the face normal and tangent of a flat-drawn vertex, from its quad's first three corners
 /// (quads are four consecutive vertices of the page; position words 0-2, UV word 3).
 const FACE: &str = "    uint hz_q = (uint(gl_VertexIndex) & ~3u) * 6u;\n    \
@@ -194,8 +204,15 @@ impl PackAtlas {
        } else {
            "vec4(-1.0, -1.0, 0.0, 0.0)"
        };
+        // The block a face belongs to: half a block behind its centre (the quad's diagonal).
+        let mid_block = if flat {
+            "vec4((floor((hz_p0 + hz_p2) * 0.5 - 0.5 * hz_Normal) + 0.5 - hz_v_pos) * 64.0, 0.0)"
+        } else {
+            "vec4(0.0)"
+        };
        let attributes = [
            ("mc_Entity", entity),
+            ("at_midBlock", mid_block),
            (
                "mc_midTexCoord",
                "vec4((hz_cell + 0.5) * hz_scale, 0.0, 1.0)",
@@ -73,6 +73,8 @@ impl DrawUniforms {
        let mut contents = vec![0u8; stride as usize * RENDER_STAGES.len()];
        for (i, slot) in contents.chunks_mut(stride as usize).enumerate() {
            slot[..4].copy_from_slice(&(i as i32).to_le_bytes());
+            // `blockEntityId` outside block entities, as Iris has it.
+            slot[8..12].copy_from_slice(&(-1i32).to_le_bytes());
        }
        let buffer = wgpu::util::DeviceExt::create_buffer_init(
            device,
@@ -106,7 +106,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {

 /// What `gbuffers_clouds` reads from the clouds' mesh (entity vertices, `vs_cloud`): the
 /// position moved by the clouds' offset, the colour of the face's shade from their palette,
-/// full sky light. Set 1 holds the clouds' uniform (`clouds::Uniform`).
+/// full light, the face's normal. Set 1 holds the clouds' uniform (`clouds::Uniform`).
 pub fn cloud_inputs() -> horizon_shaders::GbuffersInputs {
    let declarations = "layout(location = 0) in vec3 hz_v_pos;\nlayout(location = 1) in vec2 hz_v_uv;\n\
         layout(location = 2) in uint hz_v_overlay;\nlayout(location = 3) in vec4 hz_v_color;\n\
@@ -115,7 +115,7 @@ pub fn cloud_inputs() -> horizon_shaders::GbuffersInputs {
        .to_owned();
    let body = "    hz_Vertex = vec4(hz_v_pos + hz_cloud_offset.xyz, 1.0);\n    \
         hz_MultiTexCoord0 = vec4(hz_v_uv, 0.0, 1.0);\n    \
-         hz_MultiTexCoord1 = vec4(0.0, 240.0, 0.0, 1.0);\n    \
+         hz_MultiTexCoord1 = vec4(240.0, 240.0, 0.0, 1.0);\n    \
         hz_MultiTexCoord2 = hz_MultiTexCoord1;\n    \
         hz_Color = hz_cloud_colors[min(hz_v_light.x, 3u)];\n    \
         hz_Normal = dot(hz_v_normal.xyz, hz_v_normal.xyz) > 0.01 ? normalize(hz_v_normal.xyz) : vec3(0.0, 1.0, 0.0);\n"
@@ -123,7 +123,7 @@ pub fn cloud_inputs() -> horizon_shaders::GbuffersInputs {
    let attributes = [
        ("vaPosition", "hz_Vertex.xyz"),
        ("vaUV0", "hz_v_uv"),
-        ("vaUV2", "ivec2(0, 240)"),
+        ("vaUV2", "ivec2(240, 240)"),
        ("vaColor", "hz_Color"),
        ("vaNormal", "hz_Normal"),
    ];
@@ -349,10 +349,8 @@ impl PackEntities {
            bytes[0..4].copy_from_slice(&(span.stage as i32).to_le_bytes());
            bytes[4..8].copy_from_slice(&entity_id.to_le_bytes());
            bytes[8..12].copy_from_slice(&block_id.to_le_bytes());
-            for (i, c) in entity_color(run[0].layer & !super::entity_batch::OIT_ENTITY)
-                .iter()
-                .enumerate()
-            {
+            // The overlay: the layer's low 16 bits (HDR output's tier rides in the high ones).
+            for (i, c) in entity_color(run[0].layer & 0xffff).iter().enumerate() {
                bytes[16 + 4 * i..20 + 4 * i].copy_from_slice(&c.to_le_bytes());
            }
            self.uniforms.extend_from_slice(&bytes);
@@ -411,12 +409,9 @@ pub(super) fn quad_indices(device: &wgpu::Device, quads: u32) -> wgpu::Buffer {
 /// 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 & !super::entity_batch::OIT_ENTITY,
-            2 | 4 | 6 | 9 | 10 | 11 | 12 | 34
-        )
-    })
+    run.iter()
+        .step_by(4)
+        .all(|v| !matches!(v.layer & 0xffff, 2 | 4 | 6 | 9 | 10 | 11 | 12 | 34))
 }

 /// The programs of entity runs, in the order they draw.
@@ -27,12 +27,11 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
    inputs
 }

-/// The hand's projection in GL's conventions: `hud_fov` degrees, the view bob, depth scaled by
-/// `MC_HAND_DEPTH`.
-pub fn projection(hud_fov: f32, aspect: f32, far: f32, bob: Mat4) -> Mat4 {
+/// The hand's projection in GL's conventions: `hud_fov` degrees, depth scaled by
+/// `MC_HAND_DEPTH` (the view bob is in `gbufferModelView`).
+pub fn projection(hud_fov: f32, aspect: f32, far: f32) -> Mat4 {
    Mat4::from_scale(glam::Vec3::new(1.0, 1.0, HAND_DEPTH))
        * Mat4::perspective_rh_gl(hud_fov.to_radians(), aspect, 0.05, far)
-        * bob
 }

 /// The hand's vertices (also read at set 1 for normals and tangents), its uniform and quad
@@ -153,7 +152,7 @@ mod tests {
    /// apart by it), and x, y match the plain projection.
    #[test]
    fn hand_depth_is_scaled_around_the_middle() {
-        let p = projection(70.0, 16.0 / 9.0, 512.0, Mat4::IDENTITY);
+        let p = projection(70.0, 16.0 / 9.0, 512.0);
        let plain = Mat4::perspective_rh_gl(70f32.to_radians(), 16.0 / 9.0, 0.05, 512.0);
        for z in [-0.06f32, -0.5, -3.0, -400.0] {
            let v = glam::Vec4::new(0.1, -0.2, z, 1.0);
@@ -0,0 +1,460 @@
+//! A shader pack's own images (`image.<name>`) and storage buffers (`bufferObject.<n>`) on the
+//! GPU: created at the render size they depend on, kept across frames, images cleared before a
+//! frame when the pack asks.
+
+use std::collections::BTreeMap;
+
+use horizon_shaders::{BufferObject, CustomImage, Format, Kind};
+
+pub(super) struct PackImage {
+    pub(super) def: CustomImage,
+    pub(super) format: wgpu::TextureFormat,
+    pub(super) dimension: wgpu::TextureViewDimension,
+    pub(super) view: Option<wgpu::TextureView>,
+    /// Last frame's contents, for a pass that samples and stores the image (`copied`).
+    pub(super) copy: Option<wgpu::TextureView>,
+    pub(super) copied: bool,
+    /// The contents before a compute pass that reads them so (`snapshot`), apart from `copy`,
+    /// which a later pass may still sample.
+    pub(super) before: Option<wgpu::TextureView>,
+    pub(super) snapshotted: bool,
+    /// The render size the image was made for (relative images follow it).
+    made_for: [u32; 2],
+}
+
+impl PackImage {
+    pub(super) fn sample_type(&self, features: wgpu::Features) -> wgpu::TextureSampleType {
+        self.format
+            .sample_type(None, Some(features))
+            .unwrap_or(wgpu::TextureSampleType::Float { filterable: false })
+    }
+}
+
+/// The images `image.*` declares.
+pub(super) fn images(defs: Vec<CustomImage>) -> Vec<PackImage> {
+    defs.into_iter()
+        .map(|def| PackImage {
+            format: format(def.format),
+            dimension: if def.is_3d() {
+                wgpu::TextureViewDimension::D3
+            } else {
+                wgpu::TextureViewDimension::D2
+            },
+            def,
+            view: None,
+            copy: None,
+            copied: false,
+            before: None,
+            snapshotted: false,
+            made_for: [0; 2],
+        })
+        .collect()
+}
+
+/// The wgpu format of an image's internal format: a storage format of the same channels.
+pub(super) fn format(f: Format) -> wgpu::TextureFormat {
+    use wgpu::TextureFormat as T;
+    let pick = |r, rg, rgba| match f.channels {
+        1 => r,
+        2 => rg,
+        _ => rgba,
+    };
+    match (f.kind, f.bits) {
+        (Kind::Int, 8) => pick(T::R8Sint, T::Rg8Sint, T::Rgba8Sint),
+        (Kind::Int, 16) => pick(T::R16Sint, T::Rg16Sint, T::Rgba16Sint),
+        (Kind::Int, _) => pick(T::R32Sint, T::Rg32Sint, T::Rgba32Sint),
+        (Kind::Uint, 8) => pick(T::R8Uint, T::Rg8Uint, T::Rgba8Uint),
+        (Kind::Uint, 16) => pick(T::R16Uint, T::Rg16Uint, T::Rgba16Uint),
+        (Kind::Uint, _) => pick(T::R32Uint, T::Rg32Uint, T::Rgba32Uint),
+        (Kind::Float, 32) => pick(T::R32Float, T::Rg32Float, T::Rgba32Float),
+        (Kind::Float, _) => pick(T::R16Float, T::Rg16Float, T::Rgba16Float),
+        (Kind::Snorm, _) => pick(T::R8Snorm, T::Rg8Snorm, T::Rgba8Snorm),
+        (Kind::Unorm, 16) => pick(T::R16Unorm, T::Rg16Unorm, T::Rgba16Unorm),
+        (Kind::Unorm, _) => pick(T::R8Unorm, T::Rg8Unorm, T::Rgba8Unorm),
+    }
+}
+
+/// Whether this device can make `def`: its format's features, and a size in pixels within the
+/// device's limits.
+pub(super) fn makeable(device: &wgpu::Device, def: &CustomImage) -> Result<(), String> {
+    let format = format(def.format);
+    let missing = format.required_features() - device.features();
+    if !missing.is_empty() {
+        return Err(format!(
+            "{format:?} needs {missing:?}, which this GPU lacks"
+        ));
+    }
+    let limits = device.limits();
+    let largest = if def.is_3d() {
+        limits.max_texture_dimension_3d
+    } else {
+        limits.max_texture_dimension_2d
+    };
+    let [width, height, depth] = def.extent([1, 1]);
+    let relative = matches!(def.size, horizon_shaders::ImageSize::Relative(_));
+    if !relative && width.max(height).max(depth) > largest {
+        return Err(format!(
+            "{width}x{height}x{depth} is larger than this GPU's {largest}"
+        ));
+    }
+    Ok(())
+}
+
+/// Makes the images that are missing or sized for another render size; whether it made any.
+pub(super) fn resize_images(
+    device: &wgpu::Device,
+    images: &mut [PackImage],
+    size: [u32; 2],
+) -> bool {
+    let largest = device.limits().max_texture_dimension_2d;
+    let mut made = false;
+    for image in images {
+        let relative = matches!(image.def.size, horizon_shaders::ImageSize::Relative(_));
+        if image.view.is_some() && (!relative || image.made_for == size) {
+            continue;
+        }
+        made = true;
+        // A relative image larger than the render size stops at the device's limit.
+        let [width, height, depth] = image.def.extent(size);
+        let [width, height] = [width.min(largest), height.min(largest)];
+        let make = |usage| {
+            device
+                .create_texture(&wgpu::TextureDescriptor {
+                    label: Some(&image.def.name),
+                    size: wgpu::Extent3d {
+                        width,
+                        height,
+                        depth_or_array_layers: depth,
+                    },
+                    mip_level_count: 1,
+                    sample_count: 1,
+                    dimension: if image.dimension == wgpu::TextureViewDimension::D3 {
+                        wgpu::TextureDimension::D3
+                    } else {
+                        wgpu::TextureDimension::D2
+                    },
+                    format: image.format,
+                    usage: wgpu::TextureUsages::TEXTURE_BINDING | usage,
+                    view_formats: &[],
+                })
+                .create_view(&Default::default())
+        };
+        // Atomics on a texture need it made for them (Metal ignores them otherwise).
+        let atomic = device.features().contains(wgpu::Features::TEXTURE_ATOMIC)
+            && matches!(
+                image.format,
+                wgpu::TextureFormat::R32Sint | wgpu::TextureFormat::R32Uint
+            );
+        let atomic = if atomic {
+            wgpu::TextureUsages::STORAGE_ATOMIC
+        } else {
+            wgpu::TextureUsages::empty()
+        };
+        image.view = Some(make(
+            wgpu::TextureUsages::STORAGE_BINDING
+                | wgpu::TextureUsages::COPY_DST
+                | wgpu::TextureUsages::COPY_SRC
+                | atomic,
+        ));
+        image.copy = image
+            .copied
+            .then(|| make(wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::STORAGE_BINDING));
+        image.before = image
+            .snapshotted
+            .then(|| make(wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::STORAGE_BINDING));
+        image.made_for = size;
+    }
+    made
+}
+
+/// The most images a pack may have.
+pub(super) const IMAGES: usize = 64;
+
+/// Copies `image` as it is before a compute pass whose loads read it so.
+pub(super) fn snapshot(encoder: &mut wgpu::CommandEncoder, image: &PackImage) {
+    if let (Some(view), Some(before)) = (&image.view, &image.before) {
+        encoder.copy_texture_to_texture(
+            view.texture().as_image_copy(),
+            before.texture().as_image_copy(),
+            view.texture().size(),
+        );
+    }
+}
+
+/// Copies the images of `mask` (bit n: image n), which a pass samples and stores, for that pass
+/// to sample.
+pub(super) fn copy(encoder: &mut wgpu::CommandEncoder, images: &[PackImage], mask: u64) {
+    for (_, image) in images
+        .iter()
+        .enumerate()
+        .filter(|(k, _)| mask & 1 << k != 0)
+    {
+        if let (Some(view), Some(copy)) = (&image.view, &image.copy) {
+            encoder.copy_texture_to_texture(
+                view.texture().as_image_copy(),
+                copy.texture().as_image_copy(),
+                view.texture().size(),
+            );
+        }
+    }
+}
+
+/// Clears the images the pack clears before each frame: with `clear_texture` where the device
+/// has it (`clear`), else by copying from `zeros`, a buffer of zeros made large enough.
+pub(super) fn clear(
+    device: &wgpu::Device,
+    encoder: &mut wgpu::CommandEncoder,
+    images: &[PackImage],
+    clear: bool,
+    zeros: &mut Option<wgpu::Buffer>,
+) {
+    for view in images
+        .iter()
+        .filter(|i| i.def.clear)
+        .filter_map(|i| i.view.as_ref())
+    {
+        let texture = view.texture();
+        if clear {
+            encoder.clear_texture(texture, &Default::default());
+            continue;
+        }
+        let size = texture.size();
+        let texel = u64::from(texture.format().block_copy_size(None).unwrap_or(4));
+        let row = (u64::from(size.width) * texel).next_multiple_of(256);
+        // Zeros for a slice of rows at a time, the whole image taken in slices, so a large
+        // volume doesn't need a buffer of its size.
+        let rows = (ZEROS / row).clamp(1, u64::from(size.height)) as u32;
+        let bytes = row * u64::from(rows);
+        if zeros.as_ref().is_none_or(|z| z.size() < bytes) {
+            // New buffers start zeroed.
+            *zeros = Some(device.create_buffer(&wgpu::BufferDescriptor {
+                label: Some("Shader pack image zeros"),
+                size: bytes,
+                usage: wgpu::BufferUsages::COPY_SRC,
+                mapped_at_creation: false,
+            }));
+        }
+        let Some(buffer) = zeros.as_ref() else {
+            continue;
+        };
+        for z in 0..size.depth_or_array_layers {
+            for y in (0..size.height).step_by(rows as usize) {
+                let height = rows.min(size.height - y);
+                encoder.copy_buffer_to_texture(
+                    wgpu::TexelCopyBufferInfo {
+                        buffer,
+                        layout: wgpu::TexelCopyBufferLayout {
+                            offset: 0,
+                            bytes_per_row: Some(row as u32),
+                            rows_per_image: Some(height),
+                        },
+                    },
+                    wgpu::TexelCopyTextureInfo {
+                        texture,
+                        mip_level: 0,
+                        origin: wgpu::Origin3d { x: 0, y, z },
+                        aspect: wgpu::TextureAspect::All,
+                    },
+                    wgpu::Extent3d {
+                        width: size.width,
+                        height,
+                        depth_or_array_layers: 1,
+                    },
+                );
+            }
+        }
+    }
+}
+
+/// The most bytes of zeros kept to clear images without `CLEAR_TEXTURE`.
+const ZEROS: u64 = 4 << 20;
+
+/// The pack's storage buffers, bound in set 4.
+pub(super) struct Buffers {
+    pub(super) layout: wgpu::BindGroupLayout,
+    objects: BTreeMap<u32, BufferObject>,
+    pub(super) group: Option<wgpu::BindGroup>,
+    buffers: Vec<wgpu::Buffer>,
+    made_for: [u32; 2],
+}
+
+impl Buffers {
+    /// The layout of `objects`, bound in `stages`.
+    pub(super) fn new(
+        device: &wgpu::Device,
+        objects: BTreeMap<u32, BufferObject>,
+        stages: wgpu::ShaderStages,
+    ) -> Self {
+        let entries: Vec<_> = objects
+            .keys()
+            .map(|&binding| wgpu::BindGroupLayoutEntry {
+                binding,
+                visibility: stages,
+                ty: wgpu::BindingType::Buffer {
+                    ty: wgpu::BufferBindingType::Storage { read_only: false },
+                    has_dynamic_offset: false,
+                    min_binding_size: None,
+                },
+                count: None,
+            })
+            .collect();
+        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("Shader pack buffers"),
+            entries: &entries,
+        });
+        Self {
+            layout,
+            objects,
+            group: None,
+            buffers: Vec::new(),
+            made_for: [0; 2],
+        }
+    }
+
+    /// Makes the buffers (again, when one depends on the render size and it changed): their
+    /// contents start zeroed and persist across frames.
+    pub(super) fn resize(&mut self, device: &wgpu::Device, size: [u32; 2]) {
+        let relative = self
+            .objects
+            .values()
+            .any(|o| matches!(o, BufferObject::PerPixel { .. }));
+        if self.group.is_some() && (!relative || self.made_for == size) {
+            return;
+        }
+        let limits = device.limits();
+        let largest = limits
+            .max_buffer_size
+            .min(limits.max_storage_buffer_binding_size)
+            & !3;
+        self.buffers = self
+            .objects
+            .iter()
+            .map(|(binding, o)| {
+                let wanted = o.size(size).next_multiple_of(4);
+                if wanted > largest {
+                    log::warn!(
+                        "shader pack: bufferObject.{binding} wants {wanted} bytes, this device \
+                         binds at most {largest}"
+                    );
+                }
+                device.create_buffer(&wgpu::BufferDescriptor {
+                    label: Some("Shader pack buffer"),
+                    size: wanted.min(largest),
+                    usage: wgpu::BufferUsages::STORAGE,
+                    mapped_at_creation: false,
+                })
+            })
+            .collect();
+        let entries: Vec<_> = self
+            .objects
+            .keys()
+            .zip(&self.buffers)
+            .map(|(&binding, b)| wgpu::BindGroupEntry {
+                binding,
+                resource: b.as_entire_binding(),
+            })
+            .collect();
+        self.group = Some(device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("Shader pack buffers"),
+            layout: &self.layout,
+            entries: &entries,
+        }));
+        self.made_for = size;
+    }
+
+    /// Whether the pack declares buffer `binding`.
+    pub(super) fn has(&self, binding: u32) -> bool {
+        self.objects.contains_key(&binding)
+    }
+}
+
+/// A debug readback of one of the pack's images (`HORIZON_SHADER_PACK_DUMP=<name>`): every 60
+/// frames, how many of its texels are not zero, logged.
+pub(super) struct Dump {
+    name: String,
+    frame: u32,
+    pending: Option<(wgpu::Buffer, usize, [u32; 3], u32)>,
+}
+
+impl Dump {
+    pub(super) fn new() -> Option<Self> {
+        let name = std::env::var("HORIZON_SHADER_PACK_DUMP").ok()?;
+        Some(Self {
+            name,
+            frame: 0,
+            pending: None,
+        })
+    }
+
+    /// Reads last frame's copy, once its commands ran.
+    pub(super) fn read(&mut self, device: &wgpu::Device) {
+        let Some((buffer, texel, [w, h, d], row)) = self.pending.take() else {
+            return;
+        };
+        buffer.slice(..).map_async(wgpu::MapMode::Read, |_| {});
+        let _ = device.poll(wgpu::PollType::Wait {
+            submission_index: None,
+            timeout: None,
+        });
+        let Ok(data) = buffer.slice(..).get_mapped_range() else {
+            return;
+        };
+        let (mut set, mut total) = (0usize, 0usize);
+        for z in 0..d as usize {
+            for y in 0..h as usize {
+                let start = (z * h as usize + y) * row as usize;
+                for x in 0..w as usize {
+                    let at = start + x * texel;
+                    total += 1;
+                    if data[at..at + texel].iter().any(|&b| b != 0) {
+                        set += 1;
+                    }
+                }
+            }
+        }
+        log::info!(
+            "shader pack image {}: {set} of {total} texels set",
+            self.name
+        );
+    }
+
+    /// Copies the image for `read` every 60 frames.
+    pub(super) fn copy(
+        &mut self,
+        device: &wgpu::Device,
+        encoder: &mut wgpu::CommandEncoder,
+        images: &[PackImage],
+    ) {
+        self.frame += 1;
+        if !self.frame.is_multiple_of(60) {
+            return;
+        }
+        let Some(image) = images.iter().find(|i| i.def.name == self.name) else {
+            return;
+        };
+        let Some(view) = &image.view else { return };
+        let size = view.texture().size();
+        let texel = image.format.block_copy_size(None).unwrap_or(4) as usize;
+        let row = (size.width as usize * texel).next_multiple_of(256) as u32;
+        let buffer = device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Shader pack image dump"),
+            size: u64::from(row) * u64::from(size.height) * u64::from(size.depth_or_array_layers),
+            usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+            mapped_at_creation: false,
+        });
+        encoder.copy_texture_to_buffer(
+            view.texture().as_image_copy(),
+            wgpu::TexelCopyBufferInfo {
+                buffer: &buffer,
+                layout: wgpu::TexelCopyBufferLayout {
+                    offset: 0,
+                    bytes_per_row: Some(row),
+                    rows_per_image: Some(size.height),
+                },
+            },
+            size,
+        );
+        let dims = [size.width, size.height, size.depth_or_array_layers];
+        self.pending = Some((buffer, texel, dims, row));
+    }
+}
@@ -82,9 +82,9 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
         }}\n    \
         hz_Vertex = vec4(hz_p, 1.0);\n    \
         hz_MultiTexCoord0 = vec4(0.0, 0.0, 0.0, 1.0);\n    \
-         hz_MultiTexCoord1 = vec4(0.0, 240.0, 0.0, 1.0);\n    \
+         hz_MultiTexCoord1 = vec4(240.0, 240.0, 0.0, 1.0);\n    \
         hz_MultiTexCoord2 = hz_MultiTexCoord1;\n    \
-         hz_Normal = vec3(0.0, 1.0, 0.0);\n"
+         hz_Normal = vec3(0.0, 0.0, 1.0);\n"
    );
    horizon_shaders::GbuffersInputs {
        declarations,
@@ -109,7 +109,7 @@ pub fn celestial_inputs() -> horizon_shaders::GbuffersInputs {
                .into(),
        body: "    hz_Vertex = vec4(hz_v_pos, 1.0);\n    \
             hz_MultiTexCoord0 = vec4(hz_v_uv, 0.0, 1.0);\n    \
-             hz_MultiTexCoord1 = vec4(0.0, 240.0, 0.0, 1.0);\n    \
+             hz_MultiTexCoord1 = vec4(240.0, 240.0, 0.0, 1.0);\n    \
             hz_MultiTexCoord2 = hz_MultiTexCoord1;\n    \
             hz_Color = hz_v_color;\n    \
             hz_Normal = vec3(0.0, 0.0, 1.0);\n"
@@ -0,0 +1,339 @@
+//! A shader pack's custom textures (`texture.<stage>.<name>`, `texture.noise`) on the GPU, and
+//! which of them a program's sampler reads.
+
+use horizon_shaders::{CustomTexture, Group, Kind, Texels, Texture, TextureDim, TextureSource};
+
+/// What a custom texture is once uploaded: an image of ours, or one the game already has.
+pub(super) enum Image {
+    View(wgpu::TextureView),
+    Lightmap,
+    Atlas,
+}
+
+pub(super) struct PackTexture {
+    pub(super) stage: String,
+    pub(super) name: String,
+    pub(super) dimension: wgpu::TextureViewDimension,
+    pub(super) sample_type: wgpu::TextureSampleType,
+    pub(super) blur: bool,
+    pub(super) clamp: bool,
+    pub(super) image: Image,
+}
+
+/// Uploads `textures`, with a note for each the game can't provide.
+pub(super) fn upload(
+    device: &wgpu::Device,
+    queue: &wgpu::Queue,
+    textures: Vec<CustomTexture>,
+    notes: &mut Vec<String>,
+) -> Vec<PackTexture> {
+    let features = device.features();
+    let mut out = Vec::new();
+    for t in textures {
+        let (image, dimension, sample_type, blur, clamp) = match t.source {
+            TextureSource::Image(texture) => {
+                let (view, sample_type) = match create(device, queue, &texture, features) {
+                    Ok(created) => created,
+                    Err(e) => {
+                        notes.push(format!("texture.{}.{}: {e}", t.stage, t.name));
+                        continue;
+                    }
+                };
+                let dimension = match texture.dim {
+                    TextureDim::D1 => wgpu::TextureViewDimension::D1,
+                    TextureDim::D2 => wgpu::TextureViewDimension::D2,
+                    TextureDim::D3 => wgpu::TextureViewDimension::D3,
+                };
+                (
+                    Image::View(view),
+                    dimension,
+                    sample_type,
+                    texture.blur,
+                    texture.clamp,
+                )
+            }
+            TextureSource::Resource(location) => {
+                let path = location.strip_prefix("minecraft:").unwrap_or(&location);
+                let image = if path.starts_with("dynamic/lightmap") {
+                    Image::Lightmap
+                } else if path.starts_with("textures/atlas/blocks") || path == "dynamic/atlas" {
+                    Image::Atlas
+                } else {
+                    notes.push(format!(
+                        "texture.{}.{}: `{location}` is not provided yet",
+                        t.stage, t.name
+                    ));
+                    continue;
+                };
+                let float = wgpu::TextureSampleType::Float { filterable: true };
+                (image, wgpu::TextureViewDimension::D2, float, true, true)
+            }
+        };
+        out.push(PackTexture {
+            stage: t.stage,
+            name: t.name,
+            dimension,
+            sample_type,
+            blur,
+            clamp,
+            image,
+        });
+    }
+    out
+}
+
+/// The stage name of `texture.<stage>.*` a program of `group` reads.
+fn stage(group: Group) -> &'static str {
+    match group {
+        Group::Gbuffers | Group::Translucent | Group::Shadow => "gbuffers",
+        Group::Prepare => "prepare",
+        Group::Deferred => "deferred",
+        Group::Composite | Group::Final => "composite",
+        Group::ShadowComp => "shadowcomp",
+    }
+}
+
+/// The custom texture a `ty name` sampler of a `group` program reads: same stage, the same
+/// name (or another name of the same buffer, `gaux1` for `colortex4`) and dimension. A unit
+/// may hold one texture per dimension.
+pub(super) fn find(textures: &[PackTexture], group: Group, ty: &str, name: &str) -> Option<usize> {
+    let dimension = if ty.contains("1D") {
+        wgpu::TextureViewDimension::D1
+    } else if ty.contains("3D") {
+        wgpu::TextureViewDimension::D3
+    } else {
+        wgpu::TextureViewDimension::D2
+    };
+    let buffer = horizon_shaders::buffer_index(name);
+    textures.iter().position(|t| {
+        t.stage == stage(group)
+            && t.dimension == dimension
+            && (t.name == name
+                || buffer.is_some() && horizon_shaders::buffer_index(&t.name) == buffer)
+    })
+}
+
+/// `texture.noise`, if the pack has one.
+pub(super) fn noise(textures: &[PackTexture]) -> Option<&wgpu::TextureView> {
+    textures
+        .iter()
+        .find(|t| t.stage == "noise" && t.dimension == wgpu::TextureViewDimension::D2)
+        .and_then(|t| match &t.image {
+            Image::View(v) => Some(v),
+            _ => None,
+        })
+}
+
+/// The wgpu format a texture of `texture.format` is stored in: sampled, never rendered to, so
+/// any format whose texels hold the values.
+fn format(texture: &Texture) -> wgpu::TextureFormat {
+    use wgpu::TextureFormat as T;
+    let f = texture.format;
+    let pick = |r, rg, rgba| match texture.components() {
+        1 => r,
+        2 => rg,
+        _ => rgba,
+    };
+    match (f.kind, f.bits) {
+        (Kind::Unorm, b) if b <= 8 => pick(T::R8Unorm, T::Rg8Unorm, T::Rgba8Unorm),
+        (Kind::Snorm, 8) => pick(T::R8Snorm, T::Rg8Snorm, T::Rgba8Snorm),
+        (Kind::Float, 32) => pick(T::R32Float, T::Rg32Float, T::Rgba32Float),
+        (Kind::Int, 8) => pick(T::R8Sint, T::Rg8Sint, T::Rgba8Sint),
+        (Kind::Int, 16) => pick(T::R16Sint, T::Rg16Sint, T::Rgba16Sint),
+        (Kind::Int, _) => pick(T::R32Sint, T::Rg32Sint, T::Rgba32Sint),
+        (Kind::Uint, 8) => pick(T::R8Uint, T::Rg8Uint, T::Rgba8Uint),
+        (Kind::Uint, 16) => pick(T::R16Uint, T::Rg16Uint, T::Rgba16Uint),
+        (Kind::Uint, _) => pick(T::R32Uint, T::Rg32Uint, T::Rgba32Uint),
+        // 16-bit and packed normalized formats, half floats and the small floats: halves hold
+        // them closely enough.
+        _ => pick(T::R16Float, T::Rg16Float, T::Rgba16Float),
+    }
+}
+
+/// `texture`'s texels as the bytes of `format`, row after row.
+fn bytes(texture: &Texture, format: wgpu::TextureFormat) -> Vec<u8> {
+    match (&texture.texels, format) {
+        (Texels::Float(v), f) if f.block_copy_size(None) == Some(texture.components() as u32) => {
+            if matches!(
+                f,
+                wgpu::TextureFormat::R8Snorm
+                    | wgpu::TextureFormat::Rg8Snorm
+                    | wgpu::TextureFormat::Rgba8Snorm
+            ) {
+                v.iter()
+                    .map(|x| (x.clamp(-1.0, 1.0) * 127.0).round() as i8 as u8)
+                    .collect()
+            } else {
+                v.iter()
+                    .map(|x| (x.clamp(0.0, 1.0) * 255.0).round() as u8)
+                    .collect()
+            }
+        }
+        (Texels::Float(v), f)
+            if f.block_copy_size(None) == Some(4 * texture.components() as u32) =>
+        {
+            v.iter().flat_map(|x| x.to_le_bytes()).collect()
+        }
+        (Texels::Float(v), _) => v
+            .iter()
+            .flat_map(|&x| half::f16::from_f32(x).to_le_bytes())
+            .collect(),
+        (Texels::Int(v), f) => {
+            let width = f.block_copy_size(None).unwrap_or(4) as usize / texture.components();
+            v.iter()
+                .flat_map(|x| x.to_le_bytes().into_iter().take(width))
+                .collect()
+        }
+        (Texels::Uint(v), f) => {
+            let width = f.block_copy_size(None).unwrap_or(4) as usize / texture.components();
+            v.iter()
+                .flat_map(|x| x.to_le_bytes().into_iter().take(width))
+                .collect()
+        }
+    }
+}
+
+fn create(
+    device: &wgpu::Device,
+    queue: &wgpu::Queue,
+    texture: &Texture,
+    features: wgpu::Features,
+) -> Result<(wgpu::TextureView, wgpu::TextureSampleType), String> {
+    let format = format(texture);
+    let bytes = bytes(texture, format);
+    let [width, height, depth] = texture.size;
+    let limits = device.limits();
+    let largest = match texture.dim {
+        TextureDim::D1 => limits.max_texture_dimension_1d,
+        TextureDim::D2 => limits.max_texture_dimension_2d,
+        TextureDim::D3 => limits.max_texture_dimension_3d,
+    };
+    if [width, height, depth].iter().any(|&n| n > largest) {
+        return Err(format!(
+            "{width}x{height}x{depth} is larger than this device's {largest}"
+        ));
+    }
+    let row = width * format.block_copy_size(None).unwrap_or(4);
+    if bytes.len() as u64 != u64::from(row) * u64::from(height) * u64::from(depth) {
+        return Err(format!(
+            "{} bytes of texels for {width}x{height}x{depth}",
+            bytes.len()
+        ));
+    }
+    let size = wgpu::Extent3d {
+        width,
+        height,
+        depth_or_array_layers: depth,
+    };
+    let dimension = match texture.dim {
+        TextureDim::D1 => wgpu::TextureDimension::D1,
+        TextureDim::D2 => wgpu::TextureDimension::D2,
+        TextureDim::D3 => wgpu::TextureDimension::D3,
+    };
+    let tex = device.create_texture(&wgpu::TextureDescriptor {
+        label: Some("Shader pack custom texture"),
+        size,
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension,
+        format,
+        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+        view_formats: &[],
+    });
+    queue.write_texture(
+        tex.as_image_copy(),
+        &bytes,
+        wgpu::TexelCopyBufferLayout {
+            offset: 0,
+            bytes_per_row: Some(row),
+            rows_per_image: Some(height),
+        },
+        size,
+    );
+    let sample_type = format
+        .sample_type(None, Some(features))
+        .unwrap_or(wgpu::TextureSampleType::Float { filterable: false });
+    Ok((tex.create_view(&Default::default()), sample_type))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use horizon_shaders::Format;
+
+    fn lightmap(stage: &str, name: &str, dimension: wgpu::TextureViewDimension) -> PackTexture {
+        PackTexture {
+            stage: stage.into(),
+            name: name.into(),
+            dimension,
+            sample_type: wgpu::TextureSampleType::Float { filterable: true },
+            blur: false,
+            clamp: false,
+            image: Image::Lightmap,
+        }
+    }
+
+    fn texture(format: &str, texels: Texels) -> Texture {
+        Texture {
+            dim: TextureDim::D2,
+            size: [1, 1, 1],
+            format: Format::parse(format).unwrap(),
+            texels,
+            blur: false,
+            clamp: false,
+        }
+    }
+
+    #[test]
+    fn samplers_find_their_stage_name_and_dimension() {
+        use wgpu::TextureViewDimension as D;
+        let textures = [
+            lightmap("composite", "colortex4", D::D2),
+            lightmap("composite", "noisetex", D::D3),
+            lightmap("gbuffers", "gaux2", D::D2),
+            lightmap("composite", "noisetex", D::D1),
+        ];
+        assert_eq!(find(&textures, Group::Final, "sampler2D", "gaux1"), Some(0));
+        assert_eq!(
+            find(&textures, Group::Composite, "sampler3D", "noisetex"),
+            Some(1)
+        );
+        assert_eq!(
+            find(&textures, Group::Composite, "sampler1D", "noisetex"),
+            Some(3)
+        );
+        assert_eq!(
+            find(&textures, Group::Composite, "sampler2D", "noisetex"),
+            None
+        );
+        assert_eq!(
+            find(&textures, Group::Shadow, "sampler2D", "colortex5"),
+            Some(2)
+        );
+        assert_eq!(
+            find(&textures, Group::Deferred, "sampler2D", "colortex4"),
+            None
+        );
+    }
+
+    #[test]
+    fn texels_pack_into_their_format() {
+        let t = texture("RGBA8", Texels::Float(vec![0.0, 0.5, 1.0, 2.0]));
+        assert_eq!(format(&t), wgpu::TextureFormat::Rgba8Unorm);
+        assert_eq!(bytes(&t, format(&t)), [0, 128, 255, 255]);
+        let t = texture("RG8_SNORM", Texels::Float(vec![-1.0, 0.5]));
+        assert_eq!(format(&t), wgpu::TextureFormat::Rg8Snorm);
+        assert_eq!(bytes(&t, format(&t)), [0x81, 64]);
+        let t = texture("R32F", Texels::Float(vec![1.0]));
+        assert_eq!(bytes(&t, format(&t)), 1.0f32.to_le_bytes());
+        let t = texture("R16F", Texels::Float(vec![1.0]));
+        assert_eq!(format(&t), wgpu::TextureFormat::R16Float);
+        assert_eq!(bytes(&t, format(&t)), [0x00, 0x3c]);
+        let t = texture("RG16I", Texels::Int(vec![-2, 3]));
+        assert_eq!(format(&t), wgpu::TextureFormat::Rg16Sint);
+        assert_eq!(bytes(&t, format(&t)), [0xfe, 0xff, 3, 0]);
+        let t = texture("R8UI", Texels::Uint(vec![7]));
+        assert_eq!(format(&t), wgpu::TextureFormat::R8Uint);
+        assert_eq!(bytes(&t, format(&t)), [7]);
+    }
+}
@@ -30,6 +30,8 @@ pub struct PackInputs {
    pub biome_precipitation: i32,
    pub temperature: f32,
    pub rainfall: f32,
+    /// Whether the biome at the camera is known (its chunk is loaded).
+    pub biome_known: bool,
    /// `heldItemId`, `heldItemId2` (item.properties, 5.3) and `heldBlockLightValue(2)`.
    pub held_items: [i32; 2],
    pub held_light: [i32; 2],
@@ -160,6 +162,15 @@ pub const NAMES: &[&str] = &[
    "shadowModelViewInverse",
    "shadowProjection",
    "shadowProjectionInverse",
+    "cameraPositionInt",
+    "cameraPositionFract",
+    "previousCameraPositionInt",
+    "previousCameraPositionFract",
+    "eyePosition",
+    "relativeEyePosition",
+    "playerLookVector",
+    "playerBodyVector",
+    "firstPersonCamera",
 ];

 /// Values carried from frame to frame.
@@ -170,7 +181,7 @@ pub struct FrameUniforms {
    start: std::time::Instant,
    last: Option<std::time::Instant>,
    frame: u32,
-    previous: Option<(Vec3, Mat4, Mat4)>,
+    previous: Option<(glam::DVec3, Mat4, Mat4)>,
    wetness: f32,
    eye_smooth: [f32; 2],
    /// The pack's shadow settings (7.1).
@@ -282,19 +293,33 @@ impl FrameUniforms {
        let dt = self.last.map_or(0.0, |l| (now - l).as_secs_f32());
        self.last = Some(now);
        let aspect = size[0] as f32 / size[1].max(1) as f32;
-        let view = crate::camera::view_matrix(frame.yaw, frame.pitch);
+        // Packs take gbufferProjection for a plain perspective (they invert only its perspective
+        // terms): the view bob and the nausea spin belong to the model-view, as GL drew them.
+        let view = frame.bob * frame.spin * crate::camera::view_matrix(frame.yaw, frame.pitch);
        let projection = Mat4::perspective_rh_gl(
            frame.fov_degrees.to_radians(),
            aspect,
            0.05,
            frame.depth_far,
-        ) * frame.bob
-            * frame.spin;
+        );
        let camera = frame.camera.as_vec3();
-        let (previous_camera, previous_view, previous_projection) =
+        let (previous_exact, previous_view, previous_projection) =
            self.previous
-                .unwrap_or((Vec3::ZERO, Mat4::ZERO, Mat4::ZERO));
-        self.previous = Some((camera, view, projection));
+                .unwrap_or((glam::DVec3::ZERO, Mat4::ZERO, Mat4::ZERO));
+        let previous_camera = previous_exact.as_vec3();
+        self.previous = Some((frame.camera, view, projection));
+        // The camera's whole blocks and the rest, exact however far from the origin.
+        let whole = |p: glam::DVec3| p.floor();
+        let int = |p: glam::DVec3| Value::i(&whole(p).as_ivec3().to_array());
+        let fract = |p: glam::DVec3| Value::f(&(p - whole(p)).as_vec3().to_array());
+        // The player's, not the camera's: in a third-person view the camera is behind (or in
+        // front of, turned around) the eye the pack lights from.
+        let [yaw, pitch] = frame.eye_rotation.map(f32::to_radians);
+        let look = Vec3::new(
+            -yaw.sin() * pitch.cos(),
+            -pitch.sin(),
+            yaw.cos() * pitch.cos(),
+        );

        let to_view = |v: Vec3| view.transform_vector3(v);
        let sun_angle = (frame.sky.sun_angle / 360.0 + 0.25).rem_euclid(1.0);
@@ -339,6 +364,15 @@ impl FrameUniforms {
            match name {
                "cameraPosition" => v3(camera),
                "previousCameraPosition" => v3(previous_camera),
+                "cameraPositionInt" => int(frame.camera),
+                "cameraPositionFract" => fract(frame.camera),
+                "previousCameraPositionInt" => int(previous_exact),
+                "previousCameraPositionFract" => fract(previous_exact),
+                // The camera is the eye in first person.
+                "eyePosition" => v3(frame.eye.as_vec3()),
+                "relativeEyePosition" => v3((frame.camera - frame.eye).as_vec3()),
+                "playerLookVector" | "playerBodyVector" => v3(look),
+                "firstPersonCamera" => Value::i(&[i32::from(frame.first_person)]),
                "eyeAltitude" => Value::f(&[frame.camera.y as f32]),
                "upPosition" => v3(to_view(Vec3::new(0.0, 100.0, 0.0))),
                "sunPosition" => v3(sun),
@@ -450,6 +484,14 @@ fn components(name: &str) -> usize {
    match name {
        "cameraPosition"
        | "previousCameraPosition"
+        | "cameraPositionInt"
+        | "cameraPositionFract"
+        | "previousCameraPositionInt"
+        | "previousCameraPositionFract"
+        | "eyePosition"
+        | "relativeEyePosition"
+        | "playerLookVector"
+        | "playerBodyVector"
        | "upPosition"
        | "sunPosition"
        | "moonPosition"
@@ -2,7 +2,9 @@
 //! per-frame culling walk: a column whose box misses the frustum or lies past
 //! the render distance rejects all of its sections with one test, and the
 //! sections that remain are reached by index rather than by hashing keys.
-use super::{Frustum, SectionKey};
+#[cfg(test)]
+use super::Frustum;
+use super::{Cull, SectionKey};
 use crate::{fast_hash::FxHashMap, streaming::in_view_distance};
 use glam::{DVec3, Vec3};

@@ -59,6 +61,9 @@ impl<T> Resident<T> {
    pub fn values(&self) -> impl Iterator<Item = &T> {
        self.items.iter().map(|(_, v)| v)
    }
+    pub fn values_mut(&mut self) -> impl Iterator<Item = &mut T> {
+        self.items.iter_mut().map(|(_, v)| v)
+    }
    /// `key`'s value, when it is resident.
    pub fn find(&self, key: SectionKey) -> Option<&T> {
        self.slots.get(&key).map(|&slot| self.get(slot))
@@ -226,7 +231,7 @@ fn in_frustum(
    key: SectionKey,
    min_y: i32,
    camera: DVec3,
-    frustum: &Frustum,
+    frustum: &impl Cull,
    inside: bool,
    bounds: Option<[Vec3; 2]>,
 ) -> Option<(f64, Vec3)> {
@@ -258,7 +263,7 @@ impl<T> Resident<T> {
        &self,
        camera: DVec3,
        radius: i32,
-        frustum: &Frustum,
+        frustum: &impl Cull,
        reachable: impl Fn(SectionKey) -> bool,
        beyond: impl Fn(i32, i32) -> bool,
        out: &mut Vec<Visible>,
@@ -53,13 +53,7 @@ impl Weather {
                topology: wgpu::PrimitiveTopology::TriangleList,
                ..Default::default()
            },
-            depth_stencil: Some(wgpu::DepthStencilState {
-                format: wgpu::TextureFormat::Depth32Float,
-                depth_write_enabled: Some(true),
-                depth_compare: Some(wgpu::CompareFunction::GreaterEqual),
-                stencil: Default::default(),
-                bias: Default::default(),
-            }),
+            depth_stencil: Some(depth_stencil()),
            multisample: Default::default(),
            fragment: Some(wgpu::FragmentState {
                module: shader,
@@ -157,11 +151,33 @@ impl Weather {
    }
 }

+/// RenderPipelines.WEATHER: depth-tested, but no depth write, so the water
+/// and glass drawn behind the rain still show through it.
+fn depth_stencil() -> wgpu::DepthStencilState {
+    wgpu::DepthStencilState {
+        format: wgpu::TextureFormat::Depth32Float,
+        depth_write_enabled: Some(false),
+        depth_compare: Some(wgpu::CompareFunction::GreaterEqual),
+        stencil: Default::default(),
+        bias: Default::default(),
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use crate::weather::{Parameters, Time};
    use wgpu::util::DeviceExt;

+    #[test]
+    fn weather_writes_no_depth() {
+        let depth = super::depth_stencil();
+        assert_eq!(depth.depth_write_enabled, Some(false));
+        assert_eq!(
+            depth.depth_compare,
+            Some(wgpu::CompareFunction::GreaterEqual)
+        );
+    }
+
    #[repr(C)]
    #[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
    struct Case {
@@ -335,8 +335,11 @@ impl Post {
                    view_formats: &[],
                })
            };
-            let sampled =
-                wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;
+            // COPY_SRC: a native pack's material stage reads copies of them (`opaque_depth`,
+            // `opaque_color`).
+            let sampled = wgpu::TextureUsages::RENDER_ATTACHMENT
+                | wgpu::TextureUsages::TEXTURE_BINDING
+                | wgpu::TextureUsages::COPY_SRC;
            let color = make_tex("Scaled world", size, self.format, sampled)
                .create_view(&Default::default());
            // TEXTURE_BINDING: occlusion culling and TAA read it.
@@ -334,7 +334,7 @@ pub fn lod_capped(info: &wgpu::AdapterInfo) -> bool {
 }
 /// 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);
+    let distance = distance.min(crate::lod::MAX_CHUNKS);
    if lod_capped(info) {
        distance.min(INTEGRATED_LOD_DISTANCE)
    } else {
@@ -399,6 +399,10 @@ pub struct Graphics {
    /// or behind other windows, and half the worker threads. Off by default;
    /// it changes when frames are drawn, never what they show or the ticks.
    pub battery: bool,
+    /// Reuse the shader pack's last shadow map when sun, view, scene revision and
+    /// pack uniforms still match. Off by default: vanilla loaders redraw every frame
+    /// (or every `shadowInterval`), and a hit with a stale key shows old shadows.
+    pub shadow_cache: bool,
    /// The graphics API (Windows only; see `GraphicsApi`).
    pub api: GraphicsApi,
    /// The shader pack picked in `shaderpacks/` (`shader_pack_list`); empty: none. Its key is
@@ -435,6 +439,7 @@ impl Default for Graphics {
            hdr_ui_brightness: 100,
            hdr_key: "key.keyboard.unknown".into(),
            battery: false,
+            shadow_cache: false,
            api: GraphicsApi::Auto,
            shader_pack: String::new(),
        }
@@ -472,7 +477,9 @@ impl Graphics {
            let number = |d: u32| value.parse().unwrap_or(d);
            match key.trim() {
                "preset" => g.preset = Preset::parse(value),
-                "lodDistance" => g.lod_distance = number(g.lod_distance).min(1024),
+                "lodDistance" => {
+                    g.lod_distance = number(g.lod_distance).min(crate::lod::MAX_CHUNKS)
+                }
                "farDetail" => g.far_detail = FarDetail::parse(value),
                "caveCulling" => g.cave_culling = flag(g.cave_culling),
                "entityCulling" => g.entity_culling = flag(g.entity_culling),
@@ -499,7 +506,7 @@ impl Graphics {
                "hdrPaperWhite" => {
                    g.hdr_paper_white = match number(g.hdr_paper_white) {
                        0 => 0,
-                        n => n.clamp(80, 480),
+                        n => n.clamp(10, 480),
                    }
                }
                "hdrPeak" => {
@@ -514,6 +521,7 @@ impl Graphics {
                }
                "hdrKey" if value.starts_with("key.") => g.hdr_key = value.to_owned(),
                "batteryMode" => g.battery = flag(g.battery),
+                "shadowCache" => g.shadow_cache = flag(g.shadow_cache),
                "graphicsApi" => g.api = GraphicsApi::from_name(value).unwrap_or_default(),
                "pickedShaderPack" => g.shader_pack = value.to_owned(),
                "overlay" => {
@@ -530,7 +538,7 @@ impl Graphics {
    }
    pub fn serialize(&self) -> String {
        format!(
-            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrKey:{}\nbatteryMode:{}\ngraphicsApi:{}\npickedShaderPack:{}\n",
+            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrKey:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\n",
            self.preset.name(),
            self.lod_distance,
            self.far_detail.name(),
@@ -564,6 +572,7 @@ impl Graphics {
            self.hdr_ui_brightness,
            self.hdr_key,
            bool_text(self.battery),
+            bool_text(self.shadow_cache),
            self.api.name(),
            self.shader_pack,
        )
@@ -708,6 +717,7 @@ mod tests {
            hdr_ui_brightness: 60,
            hdr_key: "key.keyboard.h".into(),
            battery: true,
+            shadow_cache: true,
            api: GraphicsApi::Dx12,
            shader_pack: "Golden Hour".into(),
        };
@@ -717,7 +727,7 @@ mod tests {
        assert_eq!(Graphics::parse("hdrPeak:0\n").hdr_peak, 0);
        assert_eq!(Graphics::parse("hdrPeak:50\n").hdr_peak, 200);
        assert_eq!(Graphics::parse("hdrPaperWhite:0\n").hdr_paper_white, 0);
-        assert_eq!(Graphics::parse("hdrPaperWhite:5\n").hdr_paper_white, 80);
+        assert_eq!(Graphics::parse("hdrPaperWhite:5\n").hdr_paper_white, 10);
        // The old menus' Simple / Advanced choice is ignored, and so is the
        // shader pack older versions saved.
        assert_eq!(Graphics::parse("level:advanced\n"), Graphics::default());
@@ -774,12 +784,15 @@ mod tests {
    #[test]
    fn lod_distance_is_opt_in_and_bounded() {
        assert_eq!(Graphics::default().lod_distance, 0);
-        for distance in [0, 64, 128, 256, 512, 1024] {
+        for distance in [0, 64, 128, 256, 512, 1024, 65_536, crate::lod::MAX_CHUNKS] {
            let g = Graphics::parse(&format!("lodDistance:{distance}\n"));
            assert_eq!(g.lod_distance, distance);
            assert_eq!(Graphics::parse(&g.serialize()), g);
        }
-        assert_eq!(Graphics::parse("lodDistance:10000\n").lod_distance, 1024);
+        assert_eq!(
+            Graphics::parse("lodDistance:99999999\n").lod_distance,
+            crate::lod::MAX_CHUNKS
+        );
        assert_eq!(Graphics::parse("lodDistance:-1\n").lod_distance, 0);
        assert_eq!(Graphics::parse("lodDistance:invalid\n").lod_distance, 0);
    }
@@ -147,6 +147,34 @@ impl Style {
            dragging && active,
        );
    }
+    pub fn slider_ext(
+        &self,
+        batch: &mut HudBatch,
+        atlas: &HudAtlas,
+        (x, y, w): (f32, f32, f32),
+        label: &Text,
+        value: f32,
+        hover: bool,
+        focused: bool,
+        can_change_value: bool,
+        active: bool,
+        dragging: bool,
+    ) {
+        ui::slider_ext(
+            batch,
+            atlas,
+            x,
+            y,
+            w,
+            label,
+            value,
+            hover && active,
+            focused,
+            can_change_value,
+            active,
+            dragging && active,
+        );
+    }
    /// The cost tag and the description beside a control, wrapped to two lines.
    pub fn description(
        &self,
@@ -46,10 +46,13 @@ pub enum H {
    HdrBlackLevel,
    /// Binds `Graphics::hdr_key`.
    HdrKey,
+    /// Starts HDR calibration (`crate::hdr_calibration`).
+    HdrCalibrate,
    HdrPeak,
    HdrPaperWhite,
    HdrUiBrightness,
    BatteryMode,
+    ShadowCache,
    GraphicsApi,
 }

@@ -136,6 +139,11 @@ pub fn rows(level: Level) -> Vec<Row> {
                None,
                "Lava, fire and sunlight shine brighter than white. Needs an HDR display.",
            ),
+            h(
+                H::HdrCalibrate,
+                None,
+                "Sets the three below full screen, one test picture at a time.",
+            ),
            h(
                H::HdrBlackLevel,
                None,
@@ -306,6 +314,11 @@ pub fn rows(level: Level) -> Vec<Row> {
                None,
                "60 FPS cap (30 in menus or unfocused), half the workers: less power.",
            ),
+            h(
+                H::ShadowCache,
+                Saves,
+                "Reuses the pack shadow map when sun, view and world match. Off by default.",
+            ),
            h(
                H::Workers,
                None,
@@ -339,6 +352,28 @@ pub fn rows(level: Level) -> Vec<Row> {
 }

 const UPLOAD_STEPS: [u32; 8] = [0, 256, 512, 1024, 2048, 4096, 8192, 16384];
+/// What the LOD Distance slider stops at, in chunks: off, then each doubling
+/// up to the whole world.
+const LOD_STEPS: [u32; 18] = [
+    0,
+    64,
+    128,
+    256,
+    512,
+    1024,
+    2048,
+    4096,
+    8192,
+    16384,
+    32768,
+    65536,
+    131072,
+    262144,
+    524288,
+    1048576,
+    2097152,
+    crate::lod::MAX_CHUNKS,
+];

 /// Horizon's graphics screens supplement the vanilla options on Video Settings.
 /// Upscaling is only there while TAA is, which does it.
@@ -362,6 +397,46 @@ fn extra_rows(level: Level, settings: &Settings) -> Vec<Row> {
    rows
 }

+/// Whether the system set HDR up for the display, and whether the player kept it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Setup {
+    /// The system says nothing: the player calibrates.
+    Unknown,
+    /// Peak Brightness and Paper White follow the system.
+    Automatic,
+    /// The system said, and the player changed them anyway.
+    Changed,
+}
+fn setup(s: &Settings) -> Setup {
+    setup_of(&s.horizon, crate::graphics::reported().is_some())
+}
+fn setup_of(g: &crate::graphics::Graphics, reported: bool) -> Setup {
+    if !reported {
+        Setup::Unknown
+    } else if g.hdr_peak == 0 && g.hdr_paper_white == 0 {
+        Setup::Automatic
+    } else {
+        Setup::Changed
+    }
+}
+/// The description beside `item` where it depends on [`setup`]; `text` otherwise.
+fn description(item: Item, s: &Settings, text: &'static str) -> &'static str {
+    match (item, setup(s)) {
+        (Item::Horizon(H::HdrCalibrate), Setup::Unknown) => {
+            "Your display didn't say how bright it gets: calibrate to set it up."
+        }
+        (Item::Horizon(H::HdrCalibrate), Setup::Automatic) => {
+            "Already set up for your display. Only calibrate if HDR looks wrong."
+        }
+        (Item::Horizon(H::HdrCalibrate), Setup::Changed) => {
+            "Puts Peak Brightness and Paper White back to your display's setup."
+        }
+        (Item::Horizon(H::HdrPeak | H::HdrPaperWhite), Setup::Automatic | Setup::Changed) => {
+            "Set up for your display. Leave on Auto unless it looks wrong."
+        }
+        _ => text,
+    }
+}
 fn on_off(on: bool) -> String {
    lang::get(if on { "On" } else { "Off" })
 }
@@ -384,13 +459,17 @@ impl H {
                    .unwrap_or(UPLOAD_STEPS.len() - 1);
                Some(i as f32 / (UPLOAD_STEPS.len() - 1) as f32)
            }
+            H::LodDistance => {
+                let i = LOD_STEPS
+                    .iter()
+                    .position(|&d| d >= g.lod_distance)
+                    .unwrap_or(LOD_STEPS.len() - 1);
+                Some(i as f32 / (LOD_STEPS.len() - 1) as f32)
+            }
            H::Workers => Some(g.workers as f32 / max_workers() as f32),
            H::ResolutionScale => Some((g.resolution_scale as f32 - 50.0) / 150.0),
-            // Auto, then 80..480 by 10.
-            H::HdrPaperWhite => Some(match g.hdr_paper_white {
-                0 => 0.0,
-                n => (n as f32 - 70.0) / 410.0,
-            }),
+            // Auto, then 10..480 by 10.
+            H::HdrPaperWhite => Some(g.hdr_paper_white as f32 / 480.0),
            // Auto, then 200..2000 by 50.
            H::HdrPeak => Some(match g.hdr_peak {
                0 => 0.0,
@@ -401,6 +480,19 @@ impl H {
            _ => None,
        }
    }
+    pub fn slider_steps(self) -> Option<u32> {
+        match self {
+            H::ChunkUpdates => Some(64),
+            H::UploadBudget => Some((UPLOAD_STEPS.len() - 1) as u32),
+            H::Workers => Some(max_workers()),
+            H::ResolutionScale => Some(30),
+            H::HdrPaperWhite => Some(41),
+            H::HdrPeak => Some(37),
+            H::HdrBlackLevel => Some(100),
+            H::HdrUiBrightness => Some(15),
+            _ => None,
+        }
+    }
    fn label(self, s: &Settings) -> Text {
        let g = &s.horizon;
        match self {
@@ -454,6 +546,11 @@ impl H {
            H::Upscaling => labelled("Upscaling", g.upscaling.label()),
            H::Hdr => labelled("HDR", on_off(g.hdr)),
            H::HdrSettings => Text::literal(lang::get("HDR Settings...")),
+            H::HdrCalibrate => Text::literal(lang::get(match setup(s) {
+                Setup::Unknown => "Calibrate...",
+                Setup::Automatic => "Calibrate Anyway...",
+                Setup::Changed => "Use Automatic Setup",
+            })),
            H::HdrPaperWhite => match g.hdr_paper_white {
                0 => labelled(
                    "Paper White",
@@ -480,6 +577,7 @@ impl H {
                Text::literal("Shortcut: ").append(crate::keybinds::display_name(&g.hdr_key))
            }
            H::BatteryMode => labelled("Battery Mode", on_off(g.battery)),
+            H::ShadowCache => labelled("Shadow Cache", on_off(g.shadow_cache)),
            H::GraphicsApi => labelled("Graphics API", g.api.label()),
            H::Overlay => labelled(
                "Performance Overlay",
@@ -499,14 +597,12 @@ impl H {
                g.upload_budget_kib =
                    UPLOAD_STEPS[(v * (UPLOAD_STEPS.len() - 1) as f32).round() as usize]
            }
+            H::LodDistance => {
+                g.lod_distance = LOD_STEPS[(v * (LOD_STEPS.len() - 1) as f32).round() as usize]
+            }
            H::Workers => g.workers = (v * max_workers() as f32).round() as u32,
            H::ResolutionScale => g.resolution_scale = (50.0 + (v * 30.0).round() * 5.0) as u32,
-            H::HdrPaperWhite => {
-                g.hdr_paper_white = match (v * 41.0).round() as u32 {
-                    0 => 0,
-                    step => 70 + step * 10,
-                }
-            }
+            H::HdrPaperWhite => g.hdr_paper_white = (v * 48.0).round() as u32 * 10,
            H::HdrPeak => {
                g.hdr_peak = match (v * 37.0).round() as u32 {
                    0 => 0,
@@ -532,9 +628,6 @@ impl H {
        }
        let g = &mut s.horizon;
        match self {
-            H::LodDistance => {
-                g.lod_distance = step(&[0, 64, 128, 256, 512, 1024], g.lod_distance, back)
-            }
            H::FarDetail => {
                g.far_detail = step(&[FarDetail::Full, FarDetail::Reduced], g.far_detail, back)
            }
@@ -563,6 +656,7 @@ impl H {
            }
            H::Hdr => g.hdr = !g.hdr,
            H::BatteryMode => g.battery = !g.battery,
+            H::ShadowCache => g.shadow_cache = !g.shadow_cache,
            H::GraphicsApi => g.api = step(GraphicsApi::choices(), g.api, back),
            H::Pacing => {
                g.pacing = match g.pacing {
@@ -604,7 +698,11 @@ impl Item {
                Some("Your display or system doesn't offer HDR output.")
            }
            Item::Horizon(
-                H::HdrBlackLevel | H::HdrPeak | H::HdrPaperWhite | H::HdrUiBrightness,
+                H::HdrCalibrate
+                | H::HdrBlackLevel
+                | H::HdrPeak
+                | H::HdrPaperWhite
+                | H::HdrUiBrightness,
            ) if !s.horizon.hdr => Some("Turn HDR on to use it."),
            _ => None,
        }
@@ -621,6 +719,7 @@ impl Item {
            Item::Horizon(H::AnimatedTextures) => g.animated_textures,
            Item::Horizon(H::Hdr) => g.hdr,
            Item::Horizon(H::BatteryMode) => g.battery,
+            Item::Horizon(H::ShadowCache) => g.shadow_cache,
            Item::Vanilla(Opt::ViewBobbing) => s.view_bobbing,
            Item::Vanilla(Opt::Vsync) => s.vsync,
            Item::Vanilla(Opt::Fullscreen) => s.fullscreen,
@@ -680,6 +779,7 @@ impl Item {
                    | H::PresentMode
                    | H::Workers
                    | H::BatteryMode
+                    | H::ShadowCache
                    | H::GraphicsApi
            ) | Item::Vanilla(
                Opt::GuiScale
@@ -700,6 +800,39 @@ impl Item {
            s.horizon.preset = Preset::Custom;
        }
    }
+    pub fn slider_steps(self) -> Option<u32> {
+        match self {
+            Item::Vanilla(o) => o.slider_steps(),
+            Item::Horizon(h) => h.slider_steps(),
+        }
+    }
+    pub fn step_slider(self, s: &mut Settings, forward: bool, width: f32) {
+        if !self.available() || self.blocked(s).is_some() {
+            return;
+        }
+        let Some(pos) = self.slider(s) else {
+            return;
+        };
+        let next_pos = if let Some(steps) = self.slider_steps() {
+            let steps = steps as f32;
+            let current = (pos * steps).round();
+            let next = if forward {
+                current + 1.0
+            } else {
+                current - 1.0
+            };
+            (next / steps).clamp(0.0, 1.0)
+        } else {
+            let delta = 1.0 / (width - 8.0).max(1.0);
+            if forward {
+                (pos + delta).min(1.0)
+            } else {
+                (pos - delta).max(0.0)
+            }
+        };
+        self.set_slider(s, next_pos);
+        self.touched(s);
+    }
 }

 /// What the options screens must do after an interaction here.
@@ -713,11 +846,13 @@ pub enum Action {
    OpenHdr,
    /// Wait for a key or mouse button to bind to this name.
    BindKey(&'static str),
+    /// Start HDR calibration.
+    Calibrate,
    Done,
 }

-#[derive(Clone, Copy)]
-enum Target {
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Target {
    Item(Item),
    Button(Action),
 }
@@ -735,6 +870,8 @@ pub struct GraphicsUi {
    /// The list's scroll amount and its held scrollbar (`AbstractScrollArea`).
    scroll: ui::Scroll,
    dragging: Option<Item>,
+    pub focus: Option<Target>,
+    pub can_change_value: bool,
    /// The key binding the options screen is waiting on (`Action::BindKey`).
    pub binding: Option<&'static str>,
 }
@@ -743,6 +880,8 @@ impl GraphicsUi {
    pub fn reset(&mut self) {
        self.scroll = ui::Scroll::default();
        self.dragging = None;
+        self.focus = None;
+        self.can_change_value = false;
    }
    /// The scrollbar's column: right of the descriptions.
    fn scrollbar_x(w: f32) -> f32 {
@@ -860,8 +999,10 @@ impl GraphicsUi {
        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));
+            let is_focused = self.focus == Some(wd.target);
+            let hover = (ui::hovered(cursor, wd.x, wd.y, wd.w, 20.0)
+                && (!wd.list || (cursor.1 >= top && cursor.1 < bottom)))
+                || is_focused;
            match wd.target {
                Target::Item(item) => {
                    let (cost, text) = descriptions[index];
@@ -882,13 +1023,15 @@ impl GraphicsUi {
                        tooltip = Some(atlas.font.split(&Text::literal(lang::get(why)), 170.0));
                    }
                    match item.slider(s) {
-                        Some(value) => STYLE.slider(
+                        Some(value) => STYLE.slider_ext(
                            batch,
                            atlas,
                            (wd.x, wd.y, wd.w),
                            &label,
                            value,
                            hover || self.dragging == Some(item),
+                            is_focused,
+                            self.can_change_value && is_focused,
                            live,
                            self.dragging == Some(item),
                        ),
@@ -907,7 +1050,7 @@ impl GraphicsUi {
                        wd.x + wd.w + STYLE.gap,
                        wd.y + 1.0,
                        cost,
-                        text,
+                        description(item, s, text),
                    );
                }
                Target::Button(action) => {
@@ -993,13 +1136,26 @@ impl GraphicsUi {
            if wd.list && (y < top || y >= bottom || wd.y < top || wd.y + 20.0 > bottom) {
                continue;
            }
+            self.focus = Some(wd.target);
            return match wd.target {
-                Target::Button(action) => vec![Action::ButtonClick, action],
+                Target::Button(action) => {
+                    self.can_change_value = false;
+                    vec![Action::ButtonClick, action]
+                }
                // A disabled control does nothing: no sound, no preset change.
                Target::Item(item) if item.blocked(s).is_some() => Vec::new(),
                Target::Item(Item::Horizon(H::HdrSettings)) => {
+                    self.can_change_value = false;
                    vec![Action::ButtonClick, Action::OpenHdr]
                }
+                Target::Item(Item::Horizon(H::HdrCalibrate)) if setup(s) == Setup::Changed => {
+                    s.horizon.hdr_peak = 0;
+                    s.horizon.hdr_paper_white = 0;
+                    vec![Action::ButtonClick, Action::Changed]
+                }
+                Target::Item(Item::Horizon(H::HdrCalibrate)) => {
+                    vec![Action::ButtonClick, Action::Calibrate]
+                }
                Target::Item(Item::Horizon(H::HdrKey)) => {
                    vec![
                        Action::ButtonClick,
@@ -1008,10 +1164,12 @@ impl GraphicsUi {
                }
                Target::Item(item) => {
                    if item.slider(s).is_some() {
+                        self.can_change_value = true;
                        self.dragging = Some(item);
                        item.set_slider(s, ui::slider_value(wd.x, wd.w, x));
                        vec![Action::SliderDrag]
                    } else {
+                        self.can_change_value = false;
                        item.cycle(s, right, framebuffer);
                        vec![Action::ButtonClick, Action::Changed]
                    }
@@ -1031,6 +1189,246 @@ impl GraphicsUi {
        self.scroll.clamp(top, bottom, content);
        self.scroll.wheel(amount, 18.0, top, bottom, content);
    }
+
+    /// Mouse wheel over a control cycles it (cycle button). Sliders and disabled
+    /// rows fall through to scroll the page, matching Vanilla list behavior.
+    /// **Horizon improvement (diverges from Vanilla 26.3):** when a slider or
+    /// cycle item is keyboard-focused (`self.focus`), the wheel steps/cycles it
+    /// regardless of cursor position.  Vanilla 26.3 does not intercept the
+    /// wheel for sliders at all.
+    pub fn wheel(
+        &mut self,
+        level: Level,
+        s: &mut Settings,
+        cursor: (f32, f32),
+        (w, h): (f32, f32),
+        framebuffer: [i32; 2],
+        amount: f32,
+    ) -> Vec<Action> {
+        // Horizon improvement: focused slider/cycle intercepts wheel first.
+        if amount != 0.0
+            && self.can_change_value
+            && let Some(Target::Item(item)) = self.focus
+            && item.available()
+            && item.blocked(s).is_none()
+        {
+            if item.slider(s).is_some() {
+                item.step_slider(s, amount > 0.0, w);
+                return vec![Action::SliderDrag, Action::Changed];
+            } else if !matches!(item, Item::Horizon(H::HdrSettings)) {
+                item.cycle(s, amount > 0.0, framebuffer);
+                return vec![Action::ButtonClick, Action::Changed];
+            }
+        }
+        let (widgets, _, _) = self.layout(level, s, w, h);
+        let (top, bottom) = Self::bounds(h);
+        let hovered = widgets.iter().find(|wd| {
+            ui::hovered(cursor, wd.x, wd.y, wd.w, 20.0)
+                && (!wd.list
+                    || (cursor.1 >= top
+                        && cursor.1 < bottom
+                        && wd.y >= top
+                        && wd.y + 20.0 <= bottom))
+        });
+        if let Some(wd) = hovered
+            && let Target::Item(item) = wd.target
+            && item.available()
+            && item.blocked(s).is_none()
+            && item.slider(s).is_none()
+            && !matches!(item, Item::Horizon(H::HdrSettings))
+        {
+            if amount != 0.0 {
+                item.cycle(s, amount > 0.0, framebuffer);
+                return vec![Action::ButtonClick, Action::Changed];
+            }
+            return Vec::new();
+        }
+        self.scroll(level, s, h, amount);
+        Vec::new()
+    }
+
+    /// Keyboard navigation and value adjustments.
+    pub fn key_modifiers(
+        &mut self,
+        level: Level,
+        s: &mut Settings,
+        key: winit::keyboard::KeyCode,
+        shift: bool,
+        (w, h): (f32, f32),
+        framebuffer: [i32; 2],
+    ) -> (Vec<Action>, bool) {
+        use winit::keyboard::KeyCode as K;
+        let (widgets, _, content) = self.layout(level, s, w, h);
+        let (top, bottom) = Self::bounds(h);
+        let focusables: Vec<(Target, [f32; 4], bool)> = widgets
+            .iter()
+            .filter_map(|wd| match wd.target {
+                Target::Item(item) if item.available() && item.blocked(s).is_none() => {
+                    Some((wd.target, [wd.x, wd.y, wd.w, 20.0], wd.list))
+                }
+                Target::Button(_) => Some((wd.target, [wd.x, wd.y, wd.w, 20.0], wd.list)),
+                _ => None,
+            })
+            .collect();
+
+        if focusables.is_empty() {
+            return (Vec::new(), false);
+        }
+
+        // 1. Tab / Shift+Tab navigation
+        if key == K::Tab {
+            let cur = self
+                .focus
+                .and_then(|f| focusables.iter().position(|&(t, ..)| t == f));
+            let next_idx = match cur {
+                Some(i) => {
+                    if shift {
+                        if i == 0 { focusables.len() - 1 } else { i - 1 }
+                    } else {
+                        (i + 1) % focusables.len()
+                    }
+                }
+                None => {
+                    if shift {
+                        focusables.len() - 1
+                    } else {
+                        0
+                    }
+                }
+            };
+            let (target, [_, wy, _, wh], is_list) = focusables[next_idx];
+            self.focus = Some(target);
+            let is_slider = matches!(target, Target::Item(item) if item.slider(s).is_some());
+            self.can_change_value = is_slider;
+            if is_list {
+                if wy < top + 4.0 {
+                    self.scroll.amount -= top + 4.0 - wy;
+                } else if wy + wh > bottom - 4.0 {
+                    self.scroll.amount += wy + wh - (bottom - 4.0);
+                }
+                self.clamp_scroll(h, content);
+            }
+            return (Vec::new(), true);
+        }
+
+        // 2. Left / Right Arrow keys
+        if matches!(key, K::ArrowLeft | K::ArrowRight) {
+            let forward = key == K::ArrowRight;
+            if let Some(Target::Item(item)) = self.focus
+                && item.slider(s).is_some()
+                && self.can_change_value
+            {
+                let width = widgets
+                    .iter()
+                    .find(|wd| wd.target == Target::Item(item))
+                    .map_or(STYLE.control_width, |wd| wd.w);
+                item.step_slider(s, forward, width);
+                return (vec![Action::SliderDrag], true);
+            }
+            if let Some(cur_target) = self.focus
+                && let Some(cur_pos) = focusables.iter().position(|&(t, ..)| t == cur_target)
+            {
+                let from = focusables[cur_pos].1;
+                let rects: Vec<[f32; 4]> = focusables.iter().map(|f| f.1).collect();
+                let dir = if forward {
+                    crate::gamepad::Button::DPadRight
+                } else {
+                    crate::gamepad::Button::DPadLeft
+                };
+                if let Some(next_idx) = crate::gamepad::focus_step_rect(from, dir, &rects) {
+                    let (target, [_, wy, _, wh], is_list) = focusables[next_idx];
+                    self.focus = Some(target);
+                    self.can_change_value = false;
+                    if is_list {
+                        if wy < top + 4.0 {
+                            self.scroll.amount -= top + 4.0 - wy;
+                        } else if wy + wh > bottom - 4.0 {
+                            self.scroll.amount += wy + wh - (bottom - 4.0);
+                        }
+                        self.clamp_scroll(h, content);
+                    }
+                    return (Vec::new(), true);
+                }
+            }
+            return (Vec::new(), false);
+        }
+
+        // 3. Up / Down Arrow keys
+        if matches!(key, K::ArrowUp | K::ArrowDown) {
+            let down = key == K::ArrowDown;
+            if let Some(cur_target) = self.focus
+                && let Some(cur_pos) = focusables.iter().position(|&(t, ..)| t == cur_target)
+            {
+                let from = focusables[cur_pos].1;
+                let rects: Vec<[f32; 4]> = focusables.iter().map(|f| f.1).collect();
+                let dir = if down {
+                    crate::gamepad::Button::DPadDown
+                } else {
+                    crate::gamepad::Button::DPadUp
+                };
+                if let Some(next_idx) = crate::gamepad::focus_step_rect(from, dir, &rects) {
+                    let (target, [_, wy, _, wh], is_list) = focusables[next_idx];
+                    self.focus = Some(target);
+                    self.can_change_value = false;
+                    if is_list {
+                        if wy < top + 4.0 {
+                            self.scroll.amount -= top + 4.0 - wy;
+                        } else if wy + wh > bottom - 4.0 {
+                            self.scroll.amount += wy + wh - (bottom - 4.0);
+                        }
+                        self.clamp_scroll(h, content);
+                    }
+                    return (Vec::new(), true);
+                }
+            } else if !focusables.is_empty() {
+                let first = if down { 0 } else { focusables.len() - 1 };
+                let (target, [_, wy, _, wh], is_list) = focusables[first];
+                self.focus = Some(target);
+                self.can_change_value = false;
+                if is_list {
+                    if wy < top + 4.0 {
+                        self.scroll.amount -= top + 4.0 - wy;
+                    } else if wy + wh > bottom - 4.0 {
+                        self.scroll.amount += wy + wh - (bottom - 4.0);
+                    }
+                    self.clamp_scroll(h, content);
+                }
+                return (Vec::new(), true);
+            }
+            return (Vec::new(), false);
+        }
+
+        // 4. Space / Enter / NumpadEnter
+        if matches!(key, K::Space | K::Enter | K::NumpadEnter)
+            && let Some(target) = self.focus
+        {
+            match target {
+                Target::Item(item) => {
+                    if item.slider(s).is_some() {
+                        self.can_change_value = !self.can_change_value;
+                        return (Vec::new(), true);
+                    } else if item == Item::Horizon(H::HdrSettings) {
+                        return (vec![Action::ButtonClick, Action::OpenHdr], true);
+                    } else {
+                        item.cycle(s, shift, framebuffer);
+                        return (vec![Action::ButtonClick, Action::Changed], true);
+                    }
+                }
+                Target::Button(action) => {
+                    return (vec![Action::ButtonClick, action], true);
+                }
+            }
+        }
+
+        // 5. Escape: the screen closes on the first press, as `Screen.keyPressed` handles it
+        // before the focused slider.
+        if key == K::Escape {
+            self.can_change_value = false;
+            return (Vec::new(), false);
+        }
+
+        (Vec::new(), false)
+    }
 }

 #[cfg(test)]
@@ -1257,9 +1655,19 @@ mod tests {
        }
    }

+    #[test]
+    fn hdr_setup_follows_what_the_system_reported() {
+        let mut g = crate::graphics::Graphics::default();
+        assert_eq!(setup_of(&g, false), Setup::Unknown);
+        assert_eq!(setup_of(&g, true), Setup::Automatic);
+        g.hdr_paper_white = 80;
+        assert_eq!(setup_of(&g, true), Setup::Changed);
+        assert_eq!(setup_of(&g, false), Setup::Unknown);
+    }
+
    #[test]
    fn every_advanced_setting_has_a_description() {
-        for level in [Level::Simple, Level::Advanced] {
+        for level in [Level::Simple, Level::Advanced, Level::Hdr] {
            for row in rows(level) {
                if let Row::Setting(s) = row {
                    assert!(!s.text.is_empty(), "{:?}", s.item);
@@ -1270,11 +1678,12 @@ mod tests {
    }

    #[test]
-    fn lod_distance_cycles_in_both_levels_without_changing_near_distance() {
+    fn lod_distance_slides_in_both_levels_without_changing_near_distance() {
        let mut s = Settings::default();
        let item = Item::Horizon(H::LodDistance);
        let near = s.render_distance;
        assert_eq!(item.label(&s).plain(), "LOD Distance: Off");
+        assert_eq!(item.slider(&s), Some(0.0));
        for level in [Level::Simple, Level::Advanced] {
            let items: Vec<_> = rows(level)
                .into_iter()
@@ -1289,14 +1698,29 @@ mod tests {
                .unwrap();
            assert_eq!(items[render + 1], item);
        }
-        for distance in [64, 128, 256, 512, 1024, 0] {
-            item.cycle(&mut s, false, [854, 480]);
+        // Every stop is reachable and reads back as the same position.
+        for (i, &distance) in LOD_STEPS.iter().enumerate() {
+            let at = i as f32 / (LOD_STEPS.len() - 1) as f32;
+            item.set_slider(&mut s, at);
            assert_eq!(s.horizon.lod_distance, distance);
+            assert_eq!(item.slider(&s), Some(at));
            assert_eq!(s.render_distance, near);
        }
-        item.cycle(&mut s, true, [854, 480]);
+        // The ends are off and the whole world, which the far terrain plans.
+        item.set_slider(&mut s, 0.0);
+        assert_eq!(s.horizon.lod_distance, 0);
+        item.set_slider(&mut s, 1.0);
+        assert_eq!(s.horizon.lod_distance, crate::lod::MAX_CHUNKS);
+        assert_eq!(
+            item.label(&s).plain(),
+            format!("LOD Distance: {} chunks", crate::lod::MAX_CHUNKS)
+        );
+        item.set_slider(&mut s, 5.0 / 17.0);
        assert_eq!(s.horizon.lod_distance, 1024);
        assert_eq!(item.label(&s).plain(), "LOD Distance: 1024 chunks");
+        // A distance between stops (from the file) sits on the next one.
+        s.horizon.lod_distance = 3000;
+        assert_eq!(item.slider(&s), Some(7.0 / 17.0));
        assert_eq!(
            Item::Vanilla(Opt::RenderDistance).label(&s).plain(),
            format!("Full Detail Distance: {near} chunks")
@@ -1401,4 +1825,159 @@ mod tests {
        }
        assert_eq!(item.label(&s).plain(), "Entity Culling: On");
    }
+
+    #[test]
+    fn graphics_slider_keyboard_navigation_and_selection_toggle_parity() {
+        use winit::keyboard::KeyCode as K;
+        let mut s = Settings::default();
+        let mut ui = GraphicsUi::default();
+        let size = (480.0, 600.0);
+        let fb = [854, 480];
+
+        s.horizon.chunk_updates = 10;
+        s.horizon.resolution_scale = 100;
+
+        // 1. Tab navigates down to Chunk Updates slider (in Level::Advanced)
+        let mut found_chunk_updates = false;
+        for _ in 0..15 {
+            ui.key_modifiers(Level::Advanced, &mut s, K::Tab, false, size, fb);
+            if ui.focus == Some(Target::Item(Item::Horizon(H::ChunkUpdates))) {
+                found_chunk_updates = true;
+                break;
+            }
+        }
+        assert!(found_chunk_updates);
+        assert!(
+            ui.can_change_value,
+            "Tab onto slider activates can_change_value"
+        );
+
+        // 2. Right Arrow steps chunk updates from 10 to 11
+        let (actions, handled) =
+            ui.key_modifiers(Level::Advanced, &mut s, K::ArrowRight, false, size, fb);
+        assert!(handled);
+        assert_eq!(actions, vec![Action::SliderDrag]);
+        assert_eq!(s.horizon.chunk_updates, 11);
+
+        // 3. Left Arrow steps back to 10
+        ui.key_modifiers(Level::Advanced, &mut s, K::ArrowLeft, false, size, fb);
+        assert_eq!(s.horizon.chunk_updates, 10);
+
+        // 4. Space toggles can_change_value to false
+        ui.key_modifiers(Level::Advanced, &mut s, K::Space, false, size, fb);
+        assert!(!ui.can_change_value);
+
+        // 5. Space toggles can_change_value back to true
+        ui.key_modifiers(Level::Advanced, &mut s, K::Enter, false, size, fb);
+        assert!(ui.can_change_value);
+
+        // 6. Escape is left to the screen, which closes, even while a slider changes values
+        let (actions, handled) =
+            ui.key_modifiers(Level::Advanced, &mut s, K::Escape, false, size, fb);
+        assert!(!handled);
+        assert!(actions.is_empty());
+        assert!(!ui.can_change_value);
+
+        // 8. Tab to ResolutionScale (steps by 5%)
+        let mut found_res = false;
+        for _ in 0..20 {
+            ui.key_modifiers(Level::Advanced, &mut s, K::Tab, false, size, fb);
+            if ui.focus == Some(Target::Item(Item::Horizon(H::ResolutionScale))) {
+                found_res = true;
+                break;
+            }
+        }
+        assert!(found_res);
+        assert!(ui.can_change_value);
+        ui.key_modifiers(Level::Advanced, &mut s, K::ArrowRight, false, size, fb);
+        assert_eq!(s.horizon.resolution_scale, 105);
+        ui.key_modifiers(Level::Advanced, &mut s, K::ArrowLeft, false, size, fb);
+        assert_eq!(s.horizon.resolution_scale, 100);
+    }
+
+    #[test]
+    fn graphics_cycle_wheel_cycles_and_slider_falls_through_to_scroll() {
+        let mut s = Settings::default();
+        let mut ui = GraphicsUi::default();
+        let size = (480.0, 300.0);
+        let fb = [854, 480];
+
+        // 1. Wheel on a Cycle button: Far Detail cycles mode
+        let (widgets, _, _) = ui.layout(Level::Advanced, &s, size.0, size.1);
+        let far = widgets
+            .iter()
+            .find(|w| matches!(w.target, Target::Item(Item::Horizon(H::FarDetail))))
+            .unwrap();
+        let cursor = (far.x + 5.0, far.y + 5.0);
+        s.horizon.far_detail = FarDetail::Full;
+        let actions = ui.wheel(Level::Advanced, &mut s, cursor, size, fb, 1.0);
+        assert_eq!(actions, vec![Action::ButtonClick, Action::Changed]);
+        assert_eq!(s.horizon.far_detail, FarDetail::Reduced);
+
+        // 2. Wheel over a slider: Chunk Updates scrolls the page, doesn't change slider value
+        s.horizon.chunk_updates = 16;
+        let (widgets, _, _) = ui.layout(Level::Advanced, &s, size.0, size.1);
+        let cu = widgets
+            .iter()
+            .find(|w| matches!(w.target, Target::Item(Item::Horizon(H::ChunkUpdates))))
+            .unwrap();
+        let cursor = (cu.x + 5.0, cu.y + 5.0);
+        let scroll_before = ui.scroll.amount;
+        let actions = ui.wheel(Level::Advanced, &mut s, cursor, size, fb, -1.0);
+        assert!(actions.is_empty());
+        assert_eq!(s.horizon.chunk_updates, 16);
+        assert!(ui.scroll.amount > scroll_before);
+    }
+
+    #[test]
+    fn graphics_step_slider_matches_set_slider_for_all_options() {
+        let options = [
+            H::ChunkUpdates,
+            H::UploadBudget,
+            H::Workers,
+            H::ResolutionScale,
+            H::HdrPaperWhite,
+            H::HdrPeak,
+            H::HdrBlackLevel,
+            H::HdrUiBrightness,
+        ];
+        for h in options {
+            let item = Item::Horizon(h);
+            let steps = h.slider_steps().expect("steps defined");
+            for i in 0..steps {
+                let pos = i as f32 / steps as f32;
+                let mut s1 = Settings::default();
+                let mut s2 = Settings::default();
+                s1.horizon.hdr = true;
+                s2.horizon.hdr = true;
+                h.set_slider(&mut s1, pos);
+
+                item.step_slider(&mut s1, true, 200.0);
+                let next_pos = (i + 1) as f32 / steps as f32;
+                h.set_slider(&mut s2, next_pos);
+                assert_eq!(
+                    item.slider(&s1),
+                    item.slider(&s2),
+                    "{h:?} step forward from {i}"
+                );
+            }
+            for i in 1..=steps {
+                let pos = i as f32 / steps as f32;
+                let mut s1 = Settings::default();
+                let mut s2 = Settings::default();
+                s1.horizon.hdr = true;
+                s2.horizon.hdr = true;
+                h.set_slider(&mut s1, pos);
+
+                item.step_slider(&mut s1, false, 200.0);
+                let prev_pos = (i - 1) as f32 / steps as f32;
+                h.set_slider(&mut s2, prev_pos);
+                assert_eq!(
+                    item.slider(&s1),
+                    item.slider(&s2),
+                    "{h:?} step backward from {i}"
+                );
+            }
+        }
+    }
 }
@@ -26,8 +26,14 @@ struct Params {
    share: vec4<f32>,
    start: vec4<f32>,
    full: vec4<f32>,
+    // HDR calibration (hdr_calibration.rs): x its step (0 none, 1 black level,
+    // 2 peak, 3 paper white), y the slider in nits, z where its controls start,
+    // a share of the height.
+    calibration: vec4<f32>,
 };
@group(0) @binding(2) var<uniform> params: Params;
+// Horizon's logo, 1 inside, 0 outside, for calibration's test pictures.
+@group(0) @binding(3) var logo: texture_2d<f32>;

 // Light sources are lifted evenly rather than by a highlight curve: vanilla's
 // textures were drawn for SDR, so a curve on their brightest pixels blows out
@@ -81,6 +87,48 @@ fn lift_black(e: vec3<f32>) -> vec3<f32> {
    return e + pq(vec3(params.black)).x * pow(vec3(1.0) - n, vec3(4.0));
 }

+// Whether `p` falls on the logo drawn `size` pixels wide around `centre`.
+fn on_logo(p: vec2<f32>, centre: vec2<f32>, size: f32) -> bool {
+    let uv = (p - centre) / size + 0.5;
+    if any(uv < vec2(0.0)) || any(uv >= vec2(1.0)) {
+        return false;
+    }
+    let texels = vec2<f32>(textureDimensions(logo));
+    return textureLoad(logo, vec2<i32>(uv * texels), 0).r > 0.5;
+}
+
+// A calibration step's test picture at `p`, in nits, the way display calibration
+// tools draw them: nothing in it is bright over a large area, so the display
+// doesn't dim itself while it is judged.
+fn calibration_nits(p: vec2<f32>, size: vec2<f32>) -> f32 {
+    let top = size.y * params.calibration.z;
+    let centre = vec2(size.x, top) / 2.0;
+    let v = params.calibration.y;
+    switch u32(params.calibration.x) {
+        // Black level: the logo at the slider on 0. Lowered until it disappears,
+        // it sits on the darkest the display shows.
+        case 1u: {
+            return select(0.0, v, on_logo(p, centre, top * 0.4));
+        }
+        // Peak: a tenth of the screen at 10 000 nits, which the display clips at
+        // its brightest, the logo inside at the slider. Raised until it
+        // disappears, it sits on that brightest.
+        case 2u: {
+            let side = sqrt(0.1 * size.x * size.y);
+            if all(abs(p - centre) < vec2(side / 2.0)) {
+                return select(10000.0, v, on_logo(p, centre, side * 0.7));
+            }
+            return 0.0;
+        }
+        // Paper white: a white card at the slider, on a dim grey, to match a
+        // sheet of paper held beside the screen.
+        default: {
+            let card = vec2(top * 0.9, top * 0.6);
+            return select(3.0, v, all(abs(p - centre) < card / 2.0));
+        }
+    }
+}
+
@vertex fn vs_hdr(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
    let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
    return vec4(p * 2.0 - 1.0, 0.0, 1.0);
@@ -93,6 +141,16 @@ fn lift_black(e: vec3<f32>) -> vec3<f32> {

@fragment fn fs_hdr(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
    let at = vec2<i32>(pos.xy);
+    // Calibration: above its controls the test picture, straight in nits, past
+    // paper white, the lift and the black level.
+    let size = vec2<f32>(textureDimensions(frame));
+    if params.calibration.x > 0.5 && pos.y < size.y * params.calibration.z {
+        let nits = vec3(calibration_nits(pos.xy, size));
+        if params.pq > 0.5 {
+            return vec4(pq(nits), 1.0);
+        }
+        return vec4(nits / 80.0, 1.0);
+    }
    let f = textureLoad(frame, at, 0);
    let c = f.rgb;
    // What covers the world here (Hdr::keep_world): nothing at 0, the hand at
@@ -0,0 +1,311 @@
+//! HDR calibration (Graphics: HDR, Calibrate...): full screen, one step at a time, the way
+//! display calibration tools do it. HDR output draws each step's test picture straight in
+//! nits above a band of controls (`hdr.wgsl`, `Hdr::calibration`), past everything that
+//! shapes the game's picture, so what the player sees is the display alone:
+//!
+//! - Black Level: Horizon's logo at the slider's brightness on 0 nits; lowered until it
+//!   disappears, it sits on the darkest the display shows.
+//! - Peak Brightness: a patch of a tenth of the screen at 10 000 nits (the display clips
+//!   it at its brightest), the logo inside at the slider; raised until it disappears, it
+//!   sits on that brightest. Small, so the display doesn't dim a bright full screen; the
+//!   HDR metadata declares PQ's 10 000 nits meanwhile, so a compositor that clips at the
+//!   declared peak (KWin) lets the patch through.
+//! - Paper White: a white card at the slider, matched to a sheet of white paper held
+//!   beside the screen in the light the player plays in: white is where the eyes have
+//!   adapted to, lower in a dark room than by day (as ITU-R BT.2408's reference white).
+//!
+//! Nothing changes until Save, which writes the three into Horizon's settings; Cancel
+//! or Escape leaves them as they were.
+use crate::{
+    hud::{HudAtlas, HudBatch, rgba},
+    settings::Settings,
+    text::Text,
+    ui,
+};
+use winit::keyboard::KeyCode;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Step {
+    Black,
+    Peak,
+    PaperWhite,
+}
+const STEPS: [Step; 3] = [Step::Black, Step::Peak, Step::PaperWhite];
+
+/// What the options screen does after an input here.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Outcome {
+    Nothing,
+    Click,
+    Changed,
+    Save,
+    Cancel,
+}
+
+pub struct Calibration {
+    step: usize,
+    /// Nits, in the order of `STEPS`.
+    values: [f32; 3],
+    /// Which values were Auto (peak, paper white): saved as Auto again unless the
+    /// player moved them.
+    auto: [Option<f32>; 2],
+    dragging: bool,
+}
+
+/// Height of the band of controls at the bottom, in GUI pixels.
+const BAND: f32 = 84.0;
+
+impl Step {
+    /// Range and step of the slider, in nits: the settings' own.
+    fn range(self) -> (f32, f32, f32) {
+        match self {
+            Step::Black => (0.0, 1.0, 0.01),
+            Step::Peak => (200.0, 2000.0, 50.0),
+            Step::PaperWhite => (10.0, 480.0, 10.0),
+        }
+    }
+    fn name(self) -> &'static str {
+        match self {
+            Step::Black => "Black Level",
+            Step::Peak => "Peak Brightness",
+            Step::PaperWhite => "Paper White",
+        }
+    }
+    fn hint(self) -> &'static str {
+        match self {
+            Step::Black => "Lower it until the logo just disappears into the black.",
+            Step::Peak => "Raise it until the logo just disappears into the bright square.",
+            Step::PaperWhite => {
+                "Make the card a white that's comfortable to look at for a long time, in the light you play in."
+            }
+        }
+    }
+    /// `hdr::Calibration::step`'s number.
+    pub fn number(self) -> u32 {
+        match self {
+            Step::Black => 1,
+            Step::Peak => 2,
+            Step::PaperWhite => 3,
+        }
+    }
+}
+
+struct Layout {
+    top: f32,
+    slider: (f32, f32, f32),
+    cancel: (f32, f32, f32),
+    back: (f32, f32, f32),
+    next: (f32, f32, f32),
+}
+fn layout(w: f32, h: f32) -> Layout {
+    let top = (h - BAND).floor();
+    let cx = (w / 2.0).floor();
+    let by = top + 58.0;
+    Layout {
+        top,
+        slider: (cx - 100.0, top + 32.0, 200.0),
+        cancel: (cx - 152.0, by, 98.0),
+        back: (cx - 49.0, by, 98.0),
+        next: (cx + 54.0, by, 98.0),
+    }
+}
+fn over(cursor: (f32, f32), (x, y, w): (f32, f32, f32)) -> bool {
+    ui::hovered(cursor, x, y, w, 20.0)
+}
+
+impl Calibration {
+    pub fn new(s: &Settings) -> Self {
+        let g = &s.horizon;
+        Self {
+            step: 0,
+            values: [
+                g.hdr_black_level as f32 / 100.0,
+                g.peak_nits() as f32,
+                g.paper_white_nits() as f32,
+            ],
+            auto: [
+                (g.hdr_peak == 0).then_some(g.peak_nits() as f32),
+                (g.hdr_paper_white == 0).then_some(g.paper_white_nits() as f32),
+            ],
+            dragging: false,
+        }
+    }
+    fn current(&self) -> Step {
+        STEPS[self.step]
+    }
+    fn set(&mut self, v: f32) {
+        let (min, max, step) = self.current().range();
+        self.values[self.step] = (min + ((v - min) / step).round() * step).clamp(min, max);
+    }
+    fn label(&self) -> Text {
+        let v = self.values[self.step];
+        Text::literal(match self.current() {
+            Step::Black => format!("Black Level: {v:.2} nits"),
+            step => format!("{}: {v:.0} nits", step.name()),
+        })
+    }
+    /// The step, its nits and where the controls start (a share of the height), for
+    /// HDR output's test picture.
+    pub fn picture(&self, h: f32) -> (Step, f32, f32) {
+        (
+            self.current(),
+            self.values[self.step],
+            layout(0.0, h).top / h.max(1.0),
+        )
+    }
+    pub fn draw(&self, batch: &mut HudBatch, atlas: &HudAtlas, cursor: (f32, f32)) {
+        let (w, h) = (batch.width, batch.height);
+        let l = layout(w, h);
+        // Above the band HDR output draws the test picture over whatever is here.
+        batch.fill(atlas, 0.0, 0.0, w, h, rgba(0, 0, 0, 255));
+        batch.fill(atlas, 0.0, l.top, w, h - l.top, rgba(24, 24, 24, 255));
+        let step = self.current();
+        let title = Text::literal(format!(
+            "HDR Calibration {}/{}: {}",
+            self.step + 1,
+            STEPS.len(),
+            step.name()
+        ));
+        ui::centered_text(batch, atlas, &title, 0.0, l.top + 6.0, w, u32::MAX);
+        let hint = Text::literal(step.hint());
+        ui::centered_text(
+            batch,
+            atlas,
+            &hint,
+            0.0,
+            l.top + 18.0,
+            w,
+            rgba(160, 160, 160, 255),
+        );
+        let (min, max, _) = step.range();
+        let (x, y, sw) = l.slider;
+        ui::slider(
+            batch,
+            atlas,
+            x,
+            y,
+            sw,
+            &self.label(),
+            (self.values[self.step] - min) / (max - min),
+            over(cursor, l.slider) || self.dragging,
+            true,
+            self.dragging,
+        );
+        let last = self.step + 1 == STEPS.len();
+        for (rect, label, active) in [
+            (l.cancel, "Cancel", true),
+            (l.back, "Back", self.step > 0),
+            (l.next, if last { "Save" } else { "Next" }, true),
+        ] {
+            let hover = over(cursor, rect) && active;
+            ui::button(
+                batch,
+                atlas,
+                rect.0,
+                rect.1,
+                rect.2,
+                20.0,
+                &Text::literal(label),
+                active,
+                hover,
+            );
+        }
+    }
+    /// A press, or a drag with `drag`, at `cursor`.
+    pub fn click(&mut self, cursor: (f32, f32), (w, h): (f32, f32), drag: bool) -> Outcome {
+        let l = layout(w, h);
+        let (x, _, sw) = l.slider;
+        if drag {
+            if !self.dragging {
+                return Outcome::Nothing;
+            }
+            let (min, max, _) = self.current().range();
+            self.set(min + ui::slider_value(x, sw, cursor.0) * (max - min));
+            return Outcome::Changed;
+        }
+        if over(cursor, l.slider) {
+            self.dragging = true;
+            let (min, max, _) = self.current().range();
+            self.set(min + ui::slider_value(x, sw, cursor.0) * (max - min));
+            return Outcome::Changed;
+        }
+        if over(cursor, l.cancel) {
+            return Outcome::Cancel;
+        }
+        if over(cursor, l.back) && self.step > 0 {
+            self.step -= 1;
+            return Outcome::Click;
+        }
+        if over(cursor, l.next) {
+            return self.next();
+        }
+        Outcome::Nothing
+    }
+    fn next(&mut self) -> Outcome {
+        if self.step + 1 == STEPS.len() {
+            return Outcome::Save;
+        }
+        self.step += 1;
+        Outcome::Click
+    }
+    /// The slider let go: true if it was held (it clicks on release, as sliders do).
+    pub fn release(&mut self) -> bool {
+        std::mem::take(&mut self.dragging)
+    }
+    /// Left and Right step the slider, Enter goes on, Escape cancels.
+    pub fn key(&mut self, key: KeyCode) -> Outcome {
+        let (_, _, step) = self.current().range();
+        match key {
+            KeyCode::ArrowLeft | KeyCode::ArrowDown => {
+                self.set(self.values[self.step] - step);
+                Outcome::Changed
+            }
+            KeyCode::ArrowRight | KeyCode::ArrowUp => {
+                self.set(self.values[self.step] + step);
+                Outcome::Changed
+            }
+            KeyCode::Enter | KeyCode::NumpadEnter => self.next(),
+            KeyCode::Escape => Outcome::Cancel,
+            _ => Outcome::Nothing,
+        }
+    }
+    /// Writes what the player landed on into Horizon's settings.
+    pub fn save(&self, s: &mut Settings) {
+        let g = &mut s.horizon;
+        g.hdr_black_level = (self.values[0] * 100.0).round() as u32;
+        let [peak, paper_white] = [1, 2].map(|i| match self.auto[i - 1] {
+            Some(auto) if auto == self.values[i] => 0,
+            _ => self.values[i].round() as u32,
+        });
+        g.hdr_peak = peak;
+        g.hdr_paper_white = paper_white;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn calibration_saves_only_on_save() {
+        let mut s = Settings::default();
+        s.horizon.hdr_black_level = 5;
+        let before = s.horizon.clone();
+        let mut c = Calibration::new(&s);
+        assert_eq!(c.key(KeyCode::ArrowLeft), Outcome::Changed);
+        assert_eq!(c.key(KeyCode::ArrowLeft), Outcome::Changed);
+        assert!((c.picture(100.0).1 - 0.03).abs() < 1e-6);
+        assert_eq!(c.key(KeyCode::Escape), Outcome::Cancel);
+        assert_eq!(s.horizon, before);
+        // Black, then Peak (one step up), then Paper White, then Save.
+        assert_eq!(c.key(KeyCode::Enter), Outcome::Click);
+        assert_eq!(c.key(KeyCode::ArrowRight), Outcome::Changed);
+        assert_eq!(c.key(KeyCode::Enter), Outcome::Click);
+        assert_eq!(c.picture(100.0).0, Step::PaperWhite);
+        assert_eq!(c.key(KeyCode::Enter), Outcome::Save);
+        c.save(&mut s);
+        assert_eq!(s.horizon.hdr_black_level, 3);
+        assert_eq!(s.horizon.hdr_peak, before.peak_nits() + 50);
+        assert_eq!(s.horizon.hdr_paper_white, before.hdr_paper_white);
+    }
+}
@@ -0,0 +1,73 @@
+// Horizon's HDR emission thresholds (gfx/hdr_stats.rs), drawn when HDR output
+// turns on: for every block sprite, the brightness its pixels must reach to
+// shine, measured against the sprite itself rather than a fixed level, so a
+// resource pack's light sources shine where they are bright in their own
+// drawing. One texel per sprite (x the layer, y the array): r for a light
+// source whose bright parts shine (a torch's flame, not its handle), g for one
+// that shines all over (a froglight), b 1 when the sprite has an opaque pixel.
+@group(0) @binding(0) var sprites: texture_2d_array<f32>;
+@group(0) @binding(1) var sprites_1: texture_2d_array<f32>;
+@group(0) @binding(2) var sprites_2: texture_2d_array<f32>;
+@group(0) @binding(3) var sprites_3: texture_2d_array<f32>;
+@group(0) @binding(4) var sprites_4: texture_2d_array<f32>;
+@group(0) @binding(5) var sprites_5: texture_2d_array<f32>;
+@group(0) @binding(6) var sprites_6: texture_2d_array<f32>;
+@group(0) @binding(7) var sprites_7: texture_2d_array<f32>;
+
+struct Params {
+    // Where between the sprite's darkest and brightest opaque pixel the
+    // threshold lies, for bright parts and for all over (hdr.rs `Masks`).
+    parts: f32,
+    whole: f32,
+};
+@group(0) @binding(8) var<uniform> params: Params;
+
+// hdr.wgsl's brightness: the mean of luminance and the brightest channel, in
+// linear light.
+fn brightness(c: vec3<f32>) -> f32 {
+    let l = pow(max(c, vec3(0.0)), vec3(2.2));
+    return 0.5 * (dot(l, vec3(0.2126, 0.7152, 0.0722)) + max(l.r, max(l.g, l.b)));
+}
+
+fn texel(array: u32, at: vec2<i32>, layer: i32) -> vec4<f32> {
+    switch array {
+        case 0u: { return textureLoad(sprites, at, layer, 0); }
+        case 1u: { return textureLoad(sprites_1, at, layer, 0); }
+        case 2u: { return textureLoad(sprites_2, at, layer, 0); }
+        case 3u: { return textureLoad(sprites_3, at, layer, 0); }
+        case 4u: { return textureLoad(sprites_4, at, layer, 0); }
+        case 5u: { return textureLoad(sprites_5, at, layer, 0); }
+        case 6u: { return textureLoad(sprites_6, at, layer, 0); }
+        default: { return textureLoad(sprites_7, at, layer, 0); }
+    }
+}
+
+@vertex fn vs_stats(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
+    let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
+    return vec4(p * 2.0 - 1.0, 0.0, 1.0);
+}
+
+@fragment fn fs_stats(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
+    let layer = i32(pos.x);
+    let array = u32(pos.y);
+    // Every array holds sprites of the same size.
+    let size = vec2<i32>(textureDimensions(sprites));
+    var lo = 1.0;
+    var hi = 0.0;
+    var opaque = false;
+    for (var y = 0; y < size.y; y++) {
+        for (var x = 0; x < size.x; x++) {
+            let c = texel(array, vec2(x, y), layer);
+            if c.a >= 0.5 {
+                let b = brightness(c.rgb);
+                lo = min(lo, b);
+                hi = max(hi, b);
+                opaque = true;
+            }
+        }
+    }
+    if !opaque {
+        return vec4(1.0, 1.0, 0.0, 1.0);
+    }
+    return vec4(mix(lo, hi, params.parts), mix(lo, hi, params.whole), 1.0, 1.0);
+}
@@ -10,6 +10,8 @@ use std::{
 };
 use wgpu::util::DeviceExt;

+mod pack_text;
+
 /// A sprite's atlas region, and its size in GUI pixels: the size of the
 /// default resources' texture of that name, whatever the resolution of the
 /// pack that replaced it (vanilla's GUI code draws in those units: `blit`
@@ -78,6 +80,9 @@ pub struct HudAtlas {
    pub glint: (Vec<u8>, u32, u32),
    /// `misc/enchanted_glint_armor`, the armour layers' `GlintSampler`.
    pub glint_armor: (Vec<u8>, u32, u32),
+    /// A resource pack's own `core/text` shader for the GUI's text, translated;
+    /// none draws the text natively.
+    pub text_shader: Option<std::sync::Arc<horizon_shaders::CoreProgram>>,
    white: Rect,
 }
 /// Atlas rows reserved for glyphs rasterized at run time.
@@ -295,7 +300,18 @@ fn atlas_sprites(root: &Path, packed: &[PackedImage]) -> (Vec<PackedImage>, Vec<
        animated,
    )
 }
+/// `MissingTextureAtlasSprite`: what a sprite the atlas lacks draws as.
+pub const MISSING_SPRITE: &str = "horizon/missing";
+
 impl HudAtlas {
+    /// A sprite, or the missing one when the atlas has no such sprite (an
+    /// effect without its icon), as a stitched atlas answers.
+    pub fn sprite_or_missing(&self, name: &str) -> Option<Rect> {
+        self.sprites
+            .get(name)
+            .or_else(|| self.sprites.get(MISSING_SPRITE))
+            .copied()
+    }
    /// Keep a ready profile skin when another source only has its default.
    pub fn set_object_skin(&mut self, key: String, skin: String) {
        use std::collections::hash_map::Entry;
@@ -330,7 +346,7 @@ impl HudAtlas {
    /// The atlas of a resource root that layers packs over `defaults` (the
    /// game's own resources), whose textures give the sprites' GUI sizes.
    pub fn build_over(root: &Path, defaults: &Path) -> Result<Self> {
-        Self::pack(
+        let mut atlas = Self::pack(
            root,
            defaults,
            &[
@@ -347,7 +363,9 @@ impl HudAtlas {
                "map",
            ],
            true,
-        )
+        )?;
+        atlas.text_shader = pack_text::load(root, defaults);
+        Ok(atlas)
    }
    /// Empty slots written at run time: map textures (game/maps.rs), the
    /// minimap, downloaded skins, world and pack icons and the on-screen keyboard's text.
@@ -408,6 +426,61 @@ impl HudAtlas {
        atlas.pixels = Vec::new();
        Ok(atlas)
    }
+    /// The boot screen's atlas, before any pack loads: the theme's run-time
+    /// glyphs (`horizon/ui-text`), a white sprite and the glyph rows over
+    /// transparent black. Nothing from a pack: the boot screen draws with
+    /// the theme's bundled faces, so the font here has no sheets to read.
+    pub fn boot() -> Self {
+        let (width, height) = (1024, 1024);
+        let text_rows = 512;
+        let glyph_top = text_rows + 4;
+        let mut pixels = vec![0u8; (width * height * 4) as usize];
+        // The white sprite the fills and the font's underline pass sample.
+        for row in 0..4 {
+            let at = ((text_rows + row) * width * 4) as usize;
+            pixels[at..at + 16].fill(255);
+        }
+        let rect = |u0: u32, v0: u32, u1: u32, v1: u32, w: u32, h: u32| Rect {
+            u0: u0 as f32 / width as f32,
+            v0: v0 as f32 / height as f32,
+            u1: u1 as f32 / width as f32,
+            v1: v1 as f32 / height as f32,
+            w,
+            h,
+        };
+        let mut sprites = HashMap::new();
+        sprites.insert(
+            "horizon/white".into(),
+            rect(0, text_rows, 4, glyph_top, 4, 4),
+        );
+        sprites.insert(
+            "horizon/ui-text".into(),
+            rect(0, 0, width, text_rows, width, text_rows),
+        );
+        let white = sprites["horizon/white"];
+        Self {
+            font: crate::font::Font::load(
+                Path::new("horizon-boot"),
+                &sprites,
+                &pixels,
+                (width, height),
+                (glyph_top, height - glyph_top),
+                white,
+            ),
+            pixels,
+            width,
+            height,
+            sprites,
+            translucent: HashSet::new(),
+            flags: HashMap::new(),
+            object_skins: HashMap::new(),
+            sprite_animations: Vec::new(),
+            glint: (vec![0; 4], 1, 1),
+            glint_armor: (vec![0; 4], 1, 1),
+            white,
+            text_shader: None,
+        }
+    }
    /// Shelf placements of `images` (tallest first) in the narrowest atlas
    /// width from 4096 up that keeps the atlas, glyph rows included, within
    /// `max` texels a side; and the first row free for glyphs. High-resolution
@@ -455,13 +528,17 @@ impl HudAtlas {
        for folder in folders {
            walk(&textures.join(folder), &mut files);
        }
-        // Content mods' equipment textures, which their equipment assets name as `<ns>:<path>`.
-        if folders.contains(&"entity") {
-            for namespace in horizon_items::content_namespaces::namespaces(root) {
-                walk(
-                    &root.join(format!("assets/{namespace}/textures/entity/equipment")),
-                    &mut files,
-                );
+        // Content mods' equipment textures, which their equipment assets name as
+        // `<ns>:<path>`, and their mob effects' icons, `<ns>:mob_effect/<path>`.
+        let namespaces = horizon_items::content_namespaces::namespaces(root);
+        for (folder, textures) in [("entity", "entity/equipment"), ("mob_effect", "mob_effect")] {
+            if folders.contains(&folder) {
+                for namespace in &namespaces {
+                    walk(
+                        &root.join(format!("assets/{namespace}/textures/{textures}")),
+                        &mut files,
+                    );
+                }
            }
        }
        let assets = root.join("assets");
@@ -488,7 +565,9 @@ impl HudAtlas {
                    format!("{namespace}:{rest}")
                }
            };
-            let image = decode(path).ok()?;
+            let image = decode(path)
+                .map_err(|e| log::warn!("skipped GUI texture {}: {e}", path.display()))
+                .ok()?;
            let mcmeta = fs::read_to_string(path.with_extension("png.mcmeta")).ok();
            let animation = animation_of(mcmeta.as_deref());
            // An animated strip keeps its first frame.
@@ -564,6 +643,15 @@ impl HudAtlas {
        images.push(("horizon/white".into(), 4, 4, vec![255; 64]));
        if full {
            Self::slots(&mut images, crate::trims::slot_size(root));
+            // MissingTextureAtlasSprite.generateMissingImage: 16x16, magenta
+            // and black quarters.
+            let missing = (0..256)
+                .flat_map(|i| match (i / 16 < 8) ^ (i % 16 < 8) {
+                    true => [248, 0, 248, 255],
+                    false => [0, 0, 0, 255],
+                })
+                .collect();
+            images.push((MISSING_SPRITE.into(), 16, 16, missing));
        }
        // Blurred sprites are sampled linearly in the atlas (screen.wgsl): a
        // border wrapped from their own edges keeps the filter off their
@@ -669,6 +757,7 @@ impl HudAtlas {
            sprite_animations,
            glint,
            glint_armor,
+            text_shader: None,
            font,
            white,
        })
@@ -694,6 +783,9 @@ pub struct HudVertex {
    /// The `GLINT_TEXTURING` UV into the repeating glint texture, unused
    /// unless `uv.x >= 2`.
    pub glint_uv: [f32; 2],
+    /// 1 for the GUI's text (`RenderPipelines.GUI_TEXT`), which a resource
+    /// pack's text shader draws when it has one.
+    pub text: u32,
 }
 /// Sutherland-Hodgman against one half plane, interpolating every attribute.
 fn clip_polygon(poly: &[HudVertex], axis: usize, limit: f32, keep_below: bool) -> Vec<HudVertex> {
@@ -750,6 +842,9 @@ pub struct HudBatch {
    pub end_portal: EndPortalFill,
    /// `options.glintStrength` for the glint pass (`GlintAlpha`).
    pub glint_alpha: f32,
+    /// A resource pack text shader's `GameTime`: the day's fraction
+    /// (`gameTime % 24000` and the partial tick, over 24000).
+    pub game_time: f32,
    /// Screen's first vertex: the preceding HUD is part of its blurred background.
    pub blur_at: u32,
    /// Player object profiles encountered while painting text this frame.
@@ -804,6 +899,7 @@ impl HudBatch {
            blends: Vec::new(),
            end_portal: EndPortalFill::default(),
            glint_alpha: 0.75,
+            game_time: 0.0,
            blur_at: 0,
            inline_profiles: Vec::new(),
        }
@@ -881,6 +977,7 @@ impl HudBatch {
                color,
                depth: 0.0,
                glint_uv: [0.0, 0.0],
+                text: 0,
            });
        }
    }
@@ -900,6 +997,7 @@ impl HudBatch {
                color,
                depth: 0.0,
                glint_uv: glint_uv[i],
+                text: 0,
            });
        }
    }
@@ -911,6 +1009,7 @@ impl HudBatch {
                color,
                depth: p[i][2],
                glint_uv: [0.0, 0.0],
+                text: 0,
            });
        }
    }
@@ -1051,6 +1150,10 @@ impl HudBatch {
                [uv(cx0, cy0), uv(cx1, cy0), uv(cx1, cy1), uv(cx0, cy1)],
                tl.color,
            );
+            let end = self.vertices.len();
+            for v in &mut self.vertices[end - 6..] {
+                v.text = tl.text;
+            }
        }
        moved.push(self.vertices.len() as u32);
        let at = |v: u32| moved[((v as usize).saturating_sub(start) / 6).min(moved.len() - 1)];
@@ -1110,6 +1213,7 @@ impl HudBatch {
                color: c[i],
                depth: 0.0,
                glint_uv: [0.0, 0.0],
+                text: 0,
            });
        }
    }
@@ -1338,6 +1442,7 @@ impl HudBatch {
                        }
                    }
                };
+                let glyph = self.vertices.len();
                let start = self.vertices.len();
                draw(self, 0.0);
                lift(self, start, base);
@@ -1355,6 +1460,11 @@ impl HudBatch {
                    self.rect_uv(x0, py + 8.0, px + *advance - x0, 1.0, white, col);
                }
                lift(self, start, base + 0.01);
+                if !world {
+                    for v in &mut self.vertices[glyph..] {
+                        v.text = 1;
+                    }
+                }
            }
        }
        cursor - x
@@ -1490,6 +1600,10 @@ pub struct HudRenderer {
    uniform: wgpu::Buffer,
    buffer: wgpu::Buffer,
    capacity: u64,
+    format: wgpu::TextureFormat,
+    atlas_view: wgpu::TextureView,
+    /// The resource pack's text shader, when it has one that works.
+    pack_text: Option<pack_text::PackText>,
 }
 impl HudRenderer {
    pub fn new(
@@ -1716,8 +1830,21 @@ impl HudRenderer {
            uniform,
            buffer,
            capacity,
+            format,
+            atlas_view: view.clone(),
+            pack_text: None,
        })
    }
+    /// Draw the GUI's text with `shader` (`HudAtlas::text_shader`), or natively.
+    pub fn set_text_shader(
+        &mut self,
+        device: &wgpu::Device,
+        shader: Option<&horizon_shaders::CoreProgram>,
+    ) {
+        self.pack_text = shader.and_then(|shader| {
+            pack_text::PackText::new(device, self.format, &self.atlas_view, shader)
+        });
+    }
    pub fn animate_sprites(
        &mut self,
        uploads: &mut crate::gfx::upload::Uploads,
@@ -1771,6 +1898,38 @@ impl HudRenderer {
            *previous = state;
        }
    }
+    /// Stage `patches` into the shared atlas texture.
+    pub fn upload_patches(
+        &self,
+        uploads: &mut crate::gfx::upload::Uploads,
+        encoder: &mut wgpu::CommandEncoder,
+        patches: &[crate::font::Patch],
+    ) {
+        if let Some(texture) = &self.atlas_texture {
+            for p in patches {
+                if p.x.saturating_add(p.width) <= texture.width()
+                    && p.y.saturating_add(p.height) <= texture.height()
+                {
+                    uploads.texture(
+                        encoder,
+                        wgpu::TexelCopyTextureInfo {
+                            texture,
+                            mip_level: 0,
+                            origin: wgpu::Origin3d {
+                                x: p.x,
+                                y: p.y,
+                                z: 0,
+                            },
+                            aspect: wgpu::TextureAspect::All,
+                        },
+                        p.width,
+                        p.height,
+                        &p.rgba,
+                    );
+                }
+            }
+        }
+    }
    /// Stage the batch's atlas patches, vertices and uniform: before the
    /// frame's first pass, so the copies share one command buffer.
    pub fn prepare(
@@ -1781,26 +1940,7 @@ impl HudRenderer {
        batch: &HudBatch,
        size: [u32; 2],
    ) {
-        if let Some(texture) = &self.atlas_texture {
-            for p in &batch.patches {
-                uploads.texture(
-                    encoder,
-                    wgpu::TexelCopyTextureInfo {
-                        texture,
-                        mip_level: 0,
-                        origin: wgpu::Origin3d {
-                            x: p.x,
-                            y: p.y,
-                            z: 0,
-                        },
-                        aspect: wgpu::TextureAspect::All,
-                    },
-                    p.width,
-                    p.height,
-                    &p.rgba,
-                );
-            }
-        }
+        self.upload_patches(uploads, encoder, &batch.patches);
        if batch.vertices.is_empty() || size.contains(&0) {
            return;
        }
@@ -1834,6 +1974,9 @@ impl HudRenderer {
                batch.end_portal,
            )),
        );
+        if let Some(pack_text) = &self.pack_text {
+            pack_text.prepare(uploads, encoder, batch, size);
+        }
    }
    /// Draw the batch `prepare` staged.
    pub fn draw(
@@ -1915,15 +2058,31 @@ impl HudRenderer {
                pass.set_scissor_rect(x, y, w, h);
            }
            for (range, blend) in &runs[at..end] {
-                pass.set_pipeline(match blend {
+                let pipeline = match blend {
                    Blend::Alpha => &self.pipeline,
                    Blend::Invert => &self.invert_pipeline,
                    Blend::Additive => &self.additive_pipeline,
                    Blend::Depth(_) => &self.depth_pipeline,
                    Blend::Vignette => &self.vignette_pipeline,
                    Blend::EndPortal => &self.end_portal_pipeline,
-                });
-                pass.draw(range.clone(), 0..1);
+                };
+                match &self.pack_text {
+                    Some(pack_text) if *blend == Blend::Alpha => {
+                        for (part, text) in pack_text::text_runs(&batch.vertices, range.clone()) {
+                            if text {
+                                pack_text.draw(&mut pass, part);
+                                pass.set_bind_group(0, &self.group, &[]);
+                            } else {
+                                pass.set_pipeline(pipeline);
+                                pass.draw(part, 0..1);
+                            }
+                        }
+                    }
+                    _ => {
+                        pass.set_pipeline(pipeline);
+                        pass.draw(range.clone(), 0..1);
+                    }
+                }
            }
            at = end;
        }
@@ -2055,6 +2214,57 @@ mod tests {
        fs::remove_dir_all(&root).unwrap();
    }
    #[test]
+    fn content_mod_effect_icons_pack_under_their_namespace() {
+        let root =
+            std::env::temp_dir().join(format!("horizon-atlas-effect-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&root);
+        let icons = root.join("assets/gems/textures/mob_effect");
+        fs::create_dir_all(&icons).unwrap();
+        write_strip(&icons.join("glow.png"), 18, 18, &[[0, 0, 200, 255]], None);
+        fs::write(
+            root.join(horizon_items::content_namespaces::MARKER),
+            br#"["gems"]"#,
+        )
+        .unwrap();
+        let atlas = HudAtlas::build(&root).unwrap();
+        let rect = atlas.sprites[horizon_client_core::potions::sprite("gems:glow").as_str()];
+        assert_eq!(texel_at(&atlas, rect, 0, 0), [0, 0, 200, 255]);
+        // The HUD and the inventory draw it from the effect's id, as vanilla's.
+        let effect = crate::effects::EffectInstance::new("gems:glow", 600, 0);
+        let icon = crate::hud_overlays::EffectIcon::from(&effect);
+        let draws = crate::hud_overlays::effects(320, false, &[icon]);
+        let mut batch = HudBatch::new([320, 240]);
+        crate::hud_layout::paint(&mut batch, &atlas, &draws);
+        assert!(batch.vertices.iter().any(|v| v.uv == [rect.u0, rect.v0]));
+        let panels = crate::inventory_effects::panels(
+            320,
+            [72, 37],
+            176,
+            &[effect],
+            20.0,
+            &|_| None,
+            &|_| 60,
+        );
+        batch.vertices.clear();
+        crate::inventory_effects::paint(&mut batch, &atlas, &panels, [0, 0]);
+        assert!(batch.vertices.iter().any(|v| v.uv == [rect.u0, rect.v0]));
+        // An effect without an icon draws the missing sprite.
+        let missing = atlas.sprites[MISSING_SPRITE];
+        assert_eq!(texel_at(&atlas, missing, 0, 0), [0, 0, 0, 255]);
+        assert_eq!(texel_at(&atlas, missing, 8, 0), [248, 0, 248, 255]);
+        let effect = crate::effects::EffectInstance::new("gems:none", 600, 0);
+        let draws = crate::hud_overlays::effects(320, false, &[(&effect).into()]);
+        batch.vertices.clear();
+        crate::hud_layout::paint(&mut batch, &atlas, &draws);
+        assert!(
+            batch
+                .vertices
+                .iter()
+                .any(|v| v.uv == [missing.u0, missing.v0])
+        );
+        fs::remove_dir_all(&root).unwrap();
+    }
+    #[test]
    fn animated_block_sprites_register_and_pack_their_first_mcmeta_frame() {
        let root = animated_root();
        let atlas = HudAtlas::build(&root).unwrap();
@@ -2649,6 +2859,7 @@ mod tests {
                blends: Vec::new(),
                end_portal: EndPortalFill::default(),
                glint_alpha: 0.75,
+                game_time: 0.0,
                blur_at: 0,
                inline_profiles: Vec::new(),
            };
@@ -0,0 +1,325 @@
+//! A resource pack's `core/text` shader on the GUI's text (`RenderPipelines.GUI_TEXT`, the shader
+//! with `IS_GUI`): servers' HUDs that their pack's vertex shader moves to the screen's corners,
+//! and text effects in its fragment shader. Without one the text draws natively.
+
+use std::path::Path;
+use std::sync::Arc;
+
+use horizon_shaders::{CoreProgram, Glue};
+
+use super::{HudBatch, HudVertex};
+
+/// GUI text's vertex format (`POSITION_TEX_COLOR`) from the HUD's vertices. A glyph is two
+/// triangles here, its corners top left, top right, bottom right, top left, bottom right, bottom
+/// left; vanilla's quads go top left, bottom left, bottom right, top right, which is what
+/// `gl_VertexID % 4` tells a pack's shader. The draw passes its first vertex as its instance.
+const GLUE: Glue = Glue {
+    inputs: &[("Position", "vec3"), ("Color", "vec4"), ("UV0", "vec2")],
+    prelude: "layout(location = 0) in vec2 hz_pos;\n\
+              layout(location = 1) in vec2 hz_uv;\n\
+              layout(location = 2) in vec4 hz_color;\n\
+              const int hz_corner[6] = int[6](0, 3, 2, 0, 2, 1);\n\
+              int hz_vertex_id() {\n\
+                  int i = int(gl_VertexIndex) - int(gl_InstanceIndex);\n\
+                  return i / 6 * 4 + hz_corner[i % 6];\n\
+              }",
+    setup: "Position = vec3(hz_pos, 0.0); Color = hz_color; UV0 = hz_uv;",
+    // GL's clip depth runs from -w to w, wgpu's from 0 to w; GUI text has no depth test.
+    finish: "gl_Position.z = 0.5 * gl_Position.w;",
+    vertex_id: "hz_vertex_id()",
+};
+
+const VERTEX: &str = "assets/minecraft/shaders/core/text.vsh";
+const FRAGMENT: &str = "assets/minecraft/shaders/core/text.fsh";
+
+/// The packs' text shader over `defaults` (the game's own resources, which have vanilla's and
+/// its includes), when a pack replaces either stage.
+pub(super) fn load(root: &Path, defaults: &Path) -> Option<Arc<CoreProgram>> {
+    if root == defaults {
+        return None;
+    }
+    let read = |base: &Path, path: &str| std::fs::read_to_string(base.join(path)).ok();
+    let own =
+        |path: &str| read(root, path).filter(|text| read(defaults, path).as_ref() != Some(text));
+    let (own_vertex, own_fragment) = (own(VERTEX), own(FRAGMENT));
+    if own_vertex.is_none() && own_fragment.is_none() {
+        return None;
+    }
+    let vertex = own_vertex.or_else(|| read(defaults, VERTEX))?;
+    let fragment = own_fragment.or_else(|| read(defaults, FRAGMENT))?;
+    let include = |id: &str| {
+        let (namespace, path) = id.split_once(':')?;
+        let path = format!("assets/{namespace}/{path}");
+        read(root, &path).or_else(|| read(defaults, &path))
+    };
+    match horizon_shaders::translate_core(&vertex, &fragment, &["IS_GUI"], &include, &GLUE) {
+        Ok(program) => {
+            log::info!("the resource pack's text shader draws the GUI's text");
+            Some(Arc::new(program))
+        }
+        Err(e) => {
+            log::warn!("the resource pack's text shader is not used: {e}");
+            None
+        }
+    }
+}
+
+/// Each uniform block's offset in the one buffer (`core_shader::BLOCKS` order).
+const BLOCK_OFFSETS: [u64; 4] = [0, 256, 512, 768];
+const BLOCK_SIZES: [u64; 4] = [48, 64, 160, 48];
+
+/// The pipeline and its resources.
+pub(super) struct PackText {
+    pipeline: wgpu::RenderPipeline,
+    group: wgpu::BindGroup,
+    uniform: wgpu::Buffer,
+}
+
+impl PackText {
+    pub(super) fn new(
+        device: &wgpu::Device,
+        format: wgpu::TextureFormat,
+        atlas: &wgpu::TextureView,
+        program: &CoreProgram,
+    ) -> Option<Self> {
+        let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
+        let module = |label, module: &naga::Module| {
+            device.create_shader_module(wgpu::ShaderModuleDescriptor {
+                label: Some(label),
+                source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module.clone())),
+            })
+        };
+        let vertex = module("Resource pack text (vertex)", &program.vertex);
+        let fragment = module("Resource pack text (fragment)", &program.fragment);
+        let visibility = wgpu::ShaderStages::VERTEX_FRAGMENT;
+        let mut entries: Vec<wgpu::BindGroupLayoutEntry> = (0..4)
+            .map(|binding| wgpu::BindGroupLayoutEntry {
+                binding,
+                visibility,
+                ty: wgpu::BindingType::Buffer {
+                    ty: wgpu::BufferBindingType::Uniform,
+                    has_dynamic_offset: false,
+                    min_binding_size: None,
+                },
+                count: None,
+            })
+            .collect();
+        for (_, binding) in horizon_shaders::SAMPLERS {
+            entries.push(wgpu::BindGroupLayoutEntry {
+                binding,
+                visibility,
+                ty: wgpu::BindingType::Texture {
+                    sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                    view_dimension: wgpu::TextureViewDimension::D2,
+                    multisampled: false,
+                },
+                count: None,
+            });
+            entries.push(wgpu::BindGroupLayoutEntry {
+                binding: binding + 1,
+                visibility,
+                ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                count: None,
+            });
+        }
+        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("Resource pack text"),
+            entries: &entries,
+        });
+        let uniform = device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Resource pack text uniforms"),
+            size: 1024,
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        // The font textures' nearest filtering; every sampler a pack names reads the atlas.
+        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            label: Some("Resource pack text"),
+            ..Default::default()
+        });
+        let mut resources: Vec<wgpu::BindGroupEntry> = (0..4)
+            .map(|i| wgpu::BindGroupEntry {
+                binding: i as u32,
+                resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
+                    buffer: &uniform,
+                    offset: BLOCK_OFFSETS[i],
+                    size: wgpu::BufferSize::new(BLOCK_SIZES[i]),
+                }),
+            })
+            .collect();
+        for (_, binding) in horizon_shaders::SAMPLERS {
+            resources.push(wgpu::BindGroupEntry {
+                binding,
+                resource: wgpu::BindingResource::TextureView(atlas),
+            });
+            resources.push(wgpu::BindGroupEntry {
+                binding: binding + 1,
+                resource: wgpu::BindingResource::Sampler(&sampler),
+            });
+        }
+        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("Resource pack text"),
+            layout: &layout,
+            entries: &resources,
+        });
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("Resource pack text"),
+            bind_group_layouts: &[Some(&layout)],
+            ..Default::default()
+        });
+        let attributes = wgpu::vertex_attr_array![0=>Float32x2,1=>Float32x2,2=>Unorm8x4];
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("Resource pack text"),
+            layout: Some(&pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &vertex,
+                entry_point: Some("main"),
+                compilation_options: Default::default(),
+                buffers: &[Some(wgpu::VertexBufferLayout {
+                    array_stride: std::mem::size_of::<HudVertex>() as u64,
+                    step_mode: wgpu::VertexStepMode::Vertex,
+                    attributes: &attributes,
+                })],
+            },
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            fragment: Some(wgpu::FragmentState {
+                module: &fragment,
+                entry_point: Some("main"),
+                compilation_options: Default::default(),
+                // BlendFunction.TRANSLUCENT.
+                targets: &[Some(wgpu::ColorTargetState {
+                    format,
+                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            multiview_mask: None,
+            cache: None,
+        });
+        if let Some(e) = pollster::block_on(scope.pop()) {
+            log::warn!("the resource pack's text shader is not used: {e}");
+            return None;
+        }
+        Some(Self {
+            pipeline,
+            group,
+            uniform,
+        })
+    }
+
+    /// The frame's blocks, as `GuiRenderer` sets them for the GUI.
+    pub(super) fn prepare(
+        &self,
+        uploads: &mut crate::gfx::upload::Uploads,
+        encoder: &mut wgpu::CommandEncoder,
+        batch: &HudBatch,
+        size: [u32; 2],
+    ) {
+        uploads.buffer(encoder, &self.uniform, 0, &uniforms(batch, size));
+    }
+
+    /// Draw `range` (whole glyph quads) with the pack's shader; the caller sets its own
+    /// pipeline and bind group again after.
+    pub(super) fn draw(&self, pass: &mut wgpu::RenderPass<'_>, range: std::ops::Range<u32>) {
+        pass.set_pipeline(&self.pipeline);
+        pass.set_bind_group(0, &self.group, &[]);
+        pass.draw(range.clone(), range.start..range.start + 1);
+    }
+}
+
+/// The std140 blocks: `Globals` (`GlobalSettingsUniform.update`: the camera at the origin,
+/// `GlintAlpha`, `GameTime`, `ScreenSize`), `Projection` (`GuiRenderer`'s orthographic GUI
+/// projection, 1000 to 11000 deep, in GL's depth range), `DynamicTransforms` (the GUI's model view
+/// moving 11000 back, colour modulator white) and an empty `Fog`.
+fn uniforms(batch: &HudBatch, size: [u32; 2]) -> Vec<u8> {
+    let mut data = vec![0f32; 256];
+    let globals = 0;
+    data[globals + 3] = batch.glint_alpha;
+    data[globals + 7] = batch.game_time;
+    data[globals + 8] = size[0] as f32;
+    data[globals + 9] = size[1] as f32;
+    // Matrix4f.setOrtho(0, width, height, 0, near, far) with the GUI's scale, columns.
+    let (w, h) = (size[0] as f32 / batch.scale, size[1] as f32 / batch.scale);
+    let (near, far) = (1000.0f32, 11000.0f32);
+    let projection = 64;
+    data[projection] = 2.0 / w;
+    data[projection + 5] = -2.0 / h;
+    data[projection + 10] = 2.0 / (near - far);
+    data[projection + 12] = -1.0;
+    data[projection + 13] = 1.0;
+    data[projection + 14] = (far + near) / (near - far);
+    data[projection + 15] = 1.0;
+    let transforms = 128;
+    for (matrix, z) in [(transforms, -11000.0), (transforms + 16, 0.0)] {
+        data[matrix] = 1.0;
+        data[matrix + 5] = 1.0;
+        data[matrix + 10] = 1.0;
+        data[matrix + 14] = z;
+        data[matrix + 15] = 1.0;
+    }
+    data[transforms + 32..transforms + 36].fill(1.0);
+    bytemuck::cast_slice(&data).to_vec()
+}
+
+/// `range` split into runs of GUI text and of the rest, in order.
+pub(super) fn text_runs(
+    vertices: &[HudVertex],
+    range: std::ops::Range<u32>,
+) -> Vec<(std::ops::Range<u32>, bool)> {
+    let mut runs: Vec<(std::ops::Range<u32>, bool)> = Vec::new();
+    for i in range {
+        let text = vertices.get(i as usize).is_some_and(|v| v.text != 0);
+        match runs.last_mut() {
+            Some((run, t)) if *t == text => run.end = i + 1,
+            _ => runs.push((i..i + 1, text)),
+        }
+    }
+    runs
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_gui_projection_maps_gui_pixels_to_the_screen() {
+        let mut batch = HudBatch::new([1920, 1080]);
+        batch.scale = 4.0;
+        let data: Vec<f32> = bytemuck::cast_slice(&uniforms(&batch, [1920, 1080])).to_vec();
+        let column = |matrix: usize, c: usize| &data[matrix + 4 * c..matrix + 4 * c + 4];
+        let apply = |matrix: usize, v: [f32; 4]| -> [f32; 4] {
+            std::array::from_fn(|r| (0..4).map(|c| column(matrix, c)[r] * v[c]).sum())
+        };
+        // ProjMat * ModelViewMat * (x, y, 0, 1) for the GUI's corners: 480 x 270 GUI pixels.
+        for ([x, y], [cx, cy]) in [([0.0, 0.0], [-1.0, 1.0]), ([480.0, 270.0], [1.0, -1.0])] {
+            let clip = apply(64, apply(128, [x, y, 0.0, 1.0]));
+            assert!(
+                (clip[0] - cx).abs() < 1e-5 && (clip[1] - cy).abs() < 1e-5,
+                "{clip:?}"
+            );
+            // At GL's far plane, as vanilla's GUI is.
+            assert!((clip[2] - 1.0).abs() < 1e-4, "{clip:?}");
+        }
+        // A pack finds the GUI scale as ScreenSize.x * ProjMat[0][0] / 2.
+        assert!((data[8] * data[64] / 2.0 - 4.0).abs() < 1e-4);
+    }
+
+    #[test]
+    fn text_splits_from_the_rest() {
+        let vertex = |text| HudVertex {
+            pos: [0.0; 2],
+            uv: [0.0; 2],
+            color: 0,
+            depth: 0.0,
+            glint_uv: [0.0; 2],
+            text,
+        };
+        let vertices: Vec<HudVertex> = [0, 0, 1, 1, 1, 0].into_iter().map(vertex).collect();
+        assert_eq!(
+            text_runs(&vertices, 1..6),
+            [(1..2, false), (2..5, true), (5..6, false)]
+        );
+    }
+}
@@ -817,16 +817,23 @@ pub fn paint(batch: &mut crate::hud::HudBatch, atlas: &crate::hud::HudAtlas, dra
                color,
                blend,
            } => {
-                // Effect sprites belong to the mob_effect atlas directory;
-                // the other blitSprite ids refer to GUI sprites.
+                // Effect sprites belong to the mob_effect atlas directory (a
+                // content mod's under its namespace); the other blitSprite
+                // ids refer to GUI sprites.
                name.clear();
-                if sprite.starts_with("mob_effect/") {
-                    name.push_str(sprite);
-                } else {
+                let effect = sprite.starts_with("mob_effect/")
+                    || sprite
+                        .split_once(':')
+                        .is_some_and(|(_, path)| path.starts_with("mob_effect/"));
+                if !effect {
                    name.push_str("gui/sprites/");
-                    name.push_str(sprite);
                }
-                let Some(mut r) = atlas.sprites.get(name.as_str()).copied() else {
+                name.push_str(sprite);
+                let found = match effect {
+                    true => atlas.sprite_or_missing(&name),
+                    false => atlas.sprites.get(name.as_str()).copied(),
+                };
+                let Some(mut r) = found else {
                    continue;
                };
                if let Some([sw, sh, u, v]) = *region {
@@ -179,7 +179,7 @@ pub fn effects(w: i32, demo: bool, effects: &[EffectIcon]) -> Vec<GuiDraw> {
            blend: crate::hud_layout::Blend::Textured,
        });
        out.push(GuiDraw::Sprite {
-            sprite: Cow::Owned(format!("mob_effect/{}", e.id)),
+            sprite: Cow::Owned(horizon_client_core::potions::sprite(&e.id)),
            x: x + 3,
            y: y + 3,
            w: 18,
@@ -151,17 +151,11 @@ pub fn paint(
            );
        }
        icon.clear();
-        icon.push_str("mob_effect/");
-        icon.push_str(&panel.icon.id);
-        batch.sprite_scaled(
-            atlas,
-            &icon,
-            (panel.x + 7) as f32,
-            (panel.y + 7) as f32,
-            18.0,
-            18.0,
-            u32::MAX,
-        );
+        horizon_client_core::potions::push_sprite(&mut icon, &panel.icon.id);
+        if let Some(r) = atlas.sprite_or_missing(&icon) {
+            let (x, y) = ((panel.x + 7) as f32, (panel.y + 7) as f32);
+            batch.rect_uv(x, y, 18.0, 18.0, r, u32::MAX);
+        }
        if (text_width <= 0 || clipped)
            && cursor[0] >= panel.x
            && cursor[0] <= panel.x + panel.width
@@ -385,9 +385,40 @@ pub fn draw(
    }
 }

+/// `LoadingOverlay.MOJANG_STUDIOS_LOGO_LOCATION`, from the player's own resources.
+pub const MOJANG_STUDIOS_LOGO: &str = "gui/title/mojangstudios";
+
+/// `LoadingOverlay.extractRenderState`'s logo on a GUI `w` x `h`: the left
+/// half's corner, then each half's width and height.
+pub fn logo_layout(w: f32, h: f32) -> (i32, i32, i32, i32) {
+    let (w, h) = (f64::from(w), f64::from(h));
+    let (content_x, logo_y) = ((w * 0.5) as i32, (h * 0.5) as i32);
+    let logo_height = (w * 0.75).min(h) * 0.25;
+    let half_height = (logo_height * 0.5) as i32;
+    let half_width = (logo_height * 4.0 * 0.5) as i32;
+    (
+        content_x - half_width,
+        logo_y - half_height,
+        half_width,
+        logo_height as i32,
+    )
+}
+
+/// `GuiGraphicsExtractor.fill(x0, y0, x1, y1, color)`: the corners in either order.
+fn fill_corners(batch: &mut HudBatch, atlas: &HudAtlas, [x0, y0, x1, y1]: [i32; 4], color: u32) {
+    let (left, right) = (x0.min(x1), x0.max(x1));
+    let (top, bottom) = (y0.min(y1), y0.max(y1));
+    let (w, h) = ((right - left) as f32, (bottom - top) as f32);
+    batch.fill(atlas, left as f32, top as f32, w, h, color);
+}
+
 /// `LoadingOverlay.extractRenderState`: fills the frame with `BRAND_BACKGROUND`
-/// (Mojang red, or black when `darkMojangStudiosBackground` is set) and draws the
-/// progress line and bar.
+/// (Mojang red, or black when `darkMojangStudiosBackground` is set), draws the
+/// Mojang Studios logo as its two halves side by side, and the progress bar
+/// at 83.25% of the height (`extractProgressBar`, unfaded), with the stage's
+/// line above it. The logo's `MOJANG_LOGO` pipeline adds it (`SRC_ALPHA, ONE`):
+/// its texels are white, which alpha blending matches but for the red channel
+/// of the logo's soft edges, a 16/255 difference at most.
 pub fn draw_loading_overlay(
    batch: &mut HudBatch,
    atlas: &HudAtlas,
@@ -395,15 +426,58 @@ pub fn draw_loading_overlay(
    progress: f32,
    dark: bool,
 ) {
-    batch.fill(
+    let (w, h) = (batch.width, batch.height);
+    batch.fill(atlas, 0.0, 0.0, w, h, brand_background(dark));
+    let (x, y, half_width, logo_height) = logo_layout(w, h);
+    if let Some(r) = atlas.sprites.get(MOJANG_STUDIOS_LOGO).copied() {
+        // blit(.., u, v, width, height, 120, 60, 120, 120): the left half
+        // samples the texture's top half from u = -0.0625, the right half its
+        // bottom half from u = 0.0625 (clamped, as the logo's sampler is).
+        let at = |u: f32, v: f32| {
+            let (u, v) = ((u / 120.0).clamp(0.0, 1.0), v / 120.0);
+            (r.u0 + (r.u1 - r.u0) * u, r.v0 + (r.v1 - r.v0) * v)
+        };
+        for (i, (u, v)) in [(-0.0625, 0.0), (0.0625, 60.0)].into_iter().enumerate() {
+            let (u0, v0) = at(u, v);
+            let (u1, v1) = at(u + 120.0, v + 60.0);
+            let half = crate::hud::Rect {
+                u0,
+                v0,
+                u1,
+                v1,
+                ..r
+            };
+            let left = x + i as i32 * half_width;
+            let (lw, lh) = (half_width as f32, logo_height as f32);
+            batch.rect_uv(left as f32, y as f32, lw, lh, half, u32::MAX);
+        }
+    }
+    let bar_y = (f64::from(h) * 0.8325) as i32;
+    let x_center = (w as i32) / 2;
+    let [x0, y0, x1, y1] = [
+        x_center - half_width,
+        bar_y - 5,
+        x_center + half_width,
+        bar_y + 5,
+    ];
+    let filled = (((x1 - x0) - 2) as f32 * progress.clamp(0.0, 1.0)).ceil() as i32;
+    let white = u32::MAX;
+    fill_corners(batch, atlas, [x0 + 2, y0 + 2, x0 + filled, y1 - 2], white);
+    fill_corners(batch, atlas, [x0 + 1, y0, x1 - 1, y0 + 1], white);
+    fill_corners(batch, atlas, [x0 + 1, y1, x1 - 1, y1 - 1], white);
+    fill_corners(batch, atlas, [x0, y0, x0 + 1, y1], white);
+    fill_corners(batch, atlas, [x1, y0, x1 - 1, y1], white);
+    let text = Text::literal(line);
+    let tw = atlas.font.width_text(&text) as i32;
+    let text_top = (y0 - 9 - 3) as f32;
+    batch.text_styled(
        atlas,
-        0.0,
-        0.0,
-        batch.width,
-        batch.height,
-        brand_background(dark),
+        &text,
+        (x_center - tw / 2) as f32,
+        text_top,
+        white,
+        true,
    );
-    draw_progress(batch, atlas, line, progress);
 }

 /// The startup loading screen: the stage's line and a progress bar, centred
@@ -572,6 +646,14 @@ pub fn draw_file_fixer(
 mod tests {
    use super::*;

+    #[test]
+    fn the_mojang_logo_is_a_quarter_of_the_shorter_side_and_four_times_as_wide() {
+        // 320x240: min(240, 240) / 4 = 60 high, two halves of 120.
+        assert_eq!(logo_layout(320.0, 240.0), (40, 90, 120, 60));
+        // A tall frame sizes the logo by three quarters of its width.
+        assert_eq!(logo_layout(400.0, 500.0), (50, 213, 150, 75));
+    }
+
    #[test]
    fn progress_weighs_the_prepared_server_and_the_player_chunks() {
        assert_eq!(progress(0), 10.0 / 59.0);
@@ -35,6 +35,7 @@ pub mod gfx;
 pub mod graphics;
 pub mod graphics_style;
 pub mod graphics_ui;
+pub mod hdr_calibration;
 pub mod hud;
 pub mod hud_layout;
 pub mod hud_overlays;
@@ -53,6 +54,7 @@ pub mod mod_list;
 pub mod model_library;
 pub mod models;
 pub mod multiline_edit;
+pub mod native_emissive;
 pub mod options_file;
 pub mod options_fixes;
 pub mod options_ui;
@@ -72,6 +74,7 @@ pub mod screen_effects;
 pub mod sculk;
 pub mod section_mask;
 pub mod settings;
+pub mod shader_options;
 pub mod shader_pack_list;
 pub mod signs;
 pub mod skins;
@@ -80,6 +83,7 @@ pub mod sound_events;
 pub mod sound_preview;
 pub mod spans;
 pub mod split_layout;
+pub mod split_profiles;
 mod sprite_cache;
 pub mod sprites;
 pub mod streaming;