Merge pull request #10529 from atsauban/fix/launcher-narrow-layout-6362

fix(launcher): support responsive wrapping on narrow windows
Merge pull request #11051 from Delete228/native-dropped-item-contact
2026-11-07 11:06:11 -10:00 · 2026-11-06 21:26:42 +00:00 · 2026-11-06 21:26:37 +00:00 · 2026-11-06 21:26:31 +00:00 · 2026-11-06 21:26:25 +00:00 · 2026-11-06 21:26:18 +00:00
1624 changed files with 184360 additions and 15632 deletions
@@ -1,10 +1,16 @@
-# Trusted reviewers: one list for two things (docs/release-flow.md "Trusted reviewers").
+# Trusted reviewers: one list for three things (docs/release-flow.md "Trusted reviewers").
 # - `/nightly 2640 2642` picks the pull requests the Nightly holds (tools/ci/nightly_set.py);
-# - `/close`, `/reopen`, `/label`, `/unlabel` triage issues and pull requests (tools/ci/triage_command.py).
-# Ludovic is always allowed and isn't listed. One GitHub login per line, with who added it and when. Removing a
-# line revokes that login at once. A line with only `paused` stops both for every reviewer (Ludovic's still work).
-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)
+# - `/close`, `/reopen`, `/label`, `/unlabel` triage issues and pull requests (tools/ci/triage_command.py);
+# - `/unclaim @login` releases someone else's claim, and listed reviewers have no claim limit (tools/ci/claim_command.py).
+# One reviewer per line: `<numeric GitHub ID> <login>`, with who added it and when. The ID decides; the login is only
+# for people reading this file and for messages. A login is a name anyone can claim once its owner renames or deletes
+# the account; an ID is never reused. Get it with `gh api users/<login> --jq .id`, or run
+# `python3 tools/ci/resolve_reviewer_ids.py` to fill in the IDs and `--check` to catch renames.
+# A line in any other form (a bare login included) grants nothing. Ludovic is always allowed (OWNER_ID in
+# tools/ci/nightly_set.py) and isn't listed. Removing a line revokes that account at once. A line with only `paused`
+# stops all three for every reviewer (Ludovic's still work).
+54669067 kacpherek       # added by Ludovic, 2026-10-27
+87152661 rdbtCVS         # added by Ludovic, 2026-10-27
+84875247 Online5277      # added by Ludovic, 2026-10-27 (his top three by merged pull requests)
+86072227 levzzz5154      # added by Ludovic, 2026-10-28 (Horizon Team; author of horizon-mixins)
+87478350 Qwerner88880    # added by Ludovic, 2026-10-31 (Discord vladislav_hagen; native-mod hooks)
@@ -158,7 +158,7 @@ jobs:
        run: |
          cargo +stable fmt --check
          cargo +stable clippy --all-targets --locked -- -D warnings
-          cargo +stable test --locked --lib
+          cargo +stable test --locked --lib --bins
  # Compile and test Windows ARM64 on an actual ARM64 host, and inspect the resulting PE headers. By hand only
  # (`gh workflow run checks --ref <branch>`): GitHub's runner queue is the bottleneck, and main's runs gate the
  # releases (tools/release_train.py waits for them), so neither pull requests nor main's pushes start this
@@ -242,6 +242,18 @@ jobs:
          $output = & $launcher --version 2>&1
          if ($LASTEXITCODE -ne 0 -or -not $output) { throw 'horizon-launcher --version failed' }
          Write-Output ($output -join "`n")
+      - name: Build a native-mod game with the launcher's managed toolchain
+        working-directory: launcher
+        shell: pwsh
+        env:
+          HORIZON_LAUNCHER_HOME: ${{ runner.temp }}\horizon-native-arm64-toolchain
+          HORIZON_NATIVE_TARGET_DIR: ${{ runner.temp }}\horizon-native-arm64-toolchain\target
+        run: |
+          $ErrorActionPreference = 'Stop'
+          cargo test --release --locked --target aarch64-pc-windows-msvc --lib rust_toolchain::tests::managed_arm64_toolchain_builds_the_game -- --ignored --exact --nocapture
+          $client = Join-Path $env:HORIZON_NATIVE_TARGET_DIR 'fast/horizon-client.exe'
+          python ../tools/check_pe_arch.py arm64 $client
+          python ../tools/check_imports.py $client
  # Most pull requests leave the harnesses to parity-main, which runs them on main a batch of merges at a time
  # (.github/workflows/parity-main.yml; releases wait for it). A pull request still runs them itself when it changes
  # a harness, an oracle, a probe or the runner, or carries the run-parity label (run-parity.yml, when it is added).
@@ -264,7 +276,7 @@ jobs:
        run: |
          changed=$(git diff --name-only "$(git merge-base "$BASE_SHA" HEAD)" HEAD)
          harness=$(grep -E '^(tools/test_[a-z0-9_]+_parity\.py|tools/(parity[a-z_]*|lab)\.py|tools/parity_hosts\.json|mods/horizon/src/test/|crates/[^/]+/examples/|crates/horizon-client/src/game/[a-z_]*(fixture|harness)\.rs|\.github/workflows/parity[a-z-]*\.yml)' <<< "$changed" || true)
-          if [ -n "$harness" ] || [[ " $LABELS " == *" run-parity "* ]]; then
+          if [ -n "$harness" ] || [[ " $LABELS " == *" run-parity "* ]] || [[ " $LABELS " == *" frame-identity "* ]]; then
            echo "run=true" >> "$GITHUB_OUTPUT"
            echo "The pull request runs its harnesses: ${harness:-label run-parity}"
          else
@@ -279,6 +291,7 @@ jobs:
      base: ${{ github.event.pull_request.base.sha }}
      head: ${{ github.event.pull_request.head.sha }}
      full: ${{ contains(github.event.pull_request.labels.*.name, 'full-parity') }}
+      frame_identity: ${{ contains(github.event.pull_request.labels.*.name, 'frame-identity') }}
  # Horizon never downloads the game. These jobs need a self-hosted Linux runner
  # (label horizon-game) holding the maintainer's own copy: the official launcher's
  # game directory in HORIZON_MINECRAFT_DIR and the pinned server jar in
@@ -50,6 +50,8 @@ jobs:
          GH_TOKEN: ${{ github.token }}
          BODY: ${{ github.event.comment.body }}
          AUTHOR: ${{ github.event.comment.user.login }}
+          # Who may act is decided by this numeric ID: a login can be claimed by someone else after a rename.
+          AUTHOR_ID: ${{ github.event.comment.user.id }}
          ISSUE: ${{ github.event.issue.number }}
          COMMENT_ID: ${{ github.event.comment.id }}
          REPO: ${{ github.repository }}
@@ -83,10 +83,10 @@ jobs:
  build:
    needs: exporters
    name: build ${{ matrix.name }}
-    # Windows ARM64 is new: its failure never holds the other platforms' release (the signing job
+    # Windows ARM64 and musl are new: a failure never holds the other platforms' release (the signing job
    # needs this job, and a failed entry of it would fail it). The release steps leave the missing
-    # ARM64 files out with a warning.
-    continue-on-error: ${{ matrix.name == 'windows-arm64' }}
+    # optional archives out with a warning.
+    continue-on-error: ${{ matrix.name == 'windows-arm64' || matrix.name == 'linux-musl' }}
    strategy:
      fail-fast: false
      matrix:
@@ -98,6 +98,11 @@ jobs:
            # The server build too: packaging/server/install.sh installs it on Linux.
            server_dir: horizon-server-linux-x86_64
            server_asset: horizon-server-linux-x86_64.tar.gz
+          - name: linux-musl
+            os: ubuntu-22.04
+            musl: true
+            dir: horizon-linux-musl-x86_64
+            asset: horizon-linux-musl-x86_64.tar.gz
          - name: windows
            os: windows-latest
            dir: horizon-windows-x64
@@ -155,17 +160,19 @@ jobs:
        with:
          targets: ${{ matrix.target }}
      - uses: Swatinem/rust-cache@v2
-        if: runner.environment == 'github-hosted'
+        if: runner.environment == 'github-hosted' && !matrix.musl
        with:
          # A release restores only what a release saved: an untrusted build has its own key and saves nothing.
          shared-key: ${{ inputs.trusted && 'release' || 'nightly' }}-${{ matrix.name }}
          save-if: ${{ inputs.trusted }}
      - name: ALSA and udev headers
-        if: runner.os == 'Linux'
+        if: runner.os == 'Linux' && !matrix.musl
        run: sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
      - name: Build the client, horizon-ctl, horizon-prepare and horizon-server
+        if: ${{ !matrix.musl }}
        run: cargo build --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} -p horizon-client -p horizon-client-lib --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server
      - name: Every program the release folder takes was built
+        if: ${{ !matrix.musl }}
        run: |
          for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
            test -f "$BIN/$binary${{ matrix.exe }}" || { echo "::error::$BIN/$binary${{ matrix.exe }} is missing"; exit 1; }
@@ -193,6 +200,7 @@ jobs:
            codesign --verify --strict --verbose=2 "$BIN/$binary"
          done
      - name: Only system libraries
+        if: ${{ !matrix.musl }}
        # Windows: no non-system DLL (a "DLL not found" dialog on some players' machines). Linux: the standard
        # loader and libraries every desktop distribution has. macOS: only the system's own libraries.
        run: |
@@ -208,13 +216,14 @@ jobs:
      - name: Baseline x86-64 CPUs only
        # No POPCNT or LZCNT at all (the script says why only those): a C library's count intrinsic killed the
        # game before main on a Core 2 (#7264). Not the Mac builds: every Intel Mac that runs macOS 11 has both.
-        if: runner.os != 'macOS' && matrix.pe_arch != 'arm64'
+        if: runner.os != 'macOS' && matrix.pe_arch != 'arm64' && !matrix.musl
        run: |
          set -euo pipefail
          rustup component add llvm-tools
          ${{ runner.os == 'Windows' && 'python' || 'python3' }} tools/check_cpu_baseline.py \
            $(for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do echo "$BIN/$binary${{ matrix.exe }}"; done)
      - name: Every program starts
+        if: ${{ !matrix.musl }}
        run: |
          set -euo pipefail
          bin=$BIN
@@ -270,7 +279,15 @@ jobs:
        with:
          name: original-exporters
          path: exporters
+      - name: Build, check and package for musl in Alpine
+        if: matrix.musl
+        # Run Docker on the Ubuntu host: JavaScript actions themselves require glibc.
+        run: |
+          docker run --rm -v "$PWD:/work" -w /work \
+            -e HORIZON_VERSION -e HORIZON_NIGHTLY \
+            rust:alpine3.22 sh tools/ci/build-musl.sh
      - name: Package
+        if: ${{ !matrix.musl }}
        run: |
          set -euo pipefail
          cargo run --locked -p xtask -- package "$BIN/horizon-client${{ matrix.exe }}" "dist/${{ matrix.dir }}"
@@ -165,17 +165,23 @@ jobs:
          path: dist
          pattern: horizon-*
          merge-multiple: true
-      - name: Sign the checksums (SHA256SUMS, SHA256SUMS.sig) for the nightly channel
+      - name: Sign the checksums for the nightly channel (SHA256SUMS.sig) and for this build (SHA256SUMS.v2.sig)
+        # SHA256SUMS.sig is for launchers from before v2 (signed for "nightly"); SHA256SUMS.v2.sig is signed for
+        # nightly-<date>-<commit>, the version the release title names, which current launchers and servers
+        # require (docs/security.md, "Nightly signatures"). The publish step titles the release from the same values.
        env:
          RELEASE_SIGNING_KEY: ${{ secrets.RELEASE_SIGNING_KEY }}
          RELEASE_SIGNING_KEY_NEXT: ${{ secrets.RELEASE_SIGNING_KEY_NEXT }}
          EPHEMERAL: ${{ needs.pick.outputs.dry_run == 'true' && 'yes' || '' }}
+          ALSO_FOR: nightly-${{ needs.pick.outputs.date }}-${{ needs.pick.outputs.short }}
        run: |
          # Windows ARM64's build may fail without holding the Nightly (game-build.yml): then it is left out.
          arm64=(); if [[ -f dist/horizon-windows-arm64.zip ]]; then arm64=(dist/horizon-windows-arm64.zip)
          else echo "::warning::horizon-windows-arm64.zip is missing: SHA256SUMS goes out without it"; fi
+          musl=(); if [[ -f dist/horizon-linux-musl-x86_64.tar.gz ]]; then musl=(dist/horizon-linux-musl-x86_64.tar.gz)
+          else echo "::warning::horizon-linux-musl-x86_64.tar.gz is missing: SHA256SUMS goes out without it"; fi
          bash tools/ci/sign_release.sh nightly dist/horizon-linux-x86_64.tar.gz dist/horizon-windows-x64.zip \
-            "${arm64[@]}" \
+            "${arm64[@]}" "${musl[@]}" \
            dist/horizon-macos-arm64.zip dist/horizon-macos-x64.zip dist/horizon-server-linux-x86_64.tar.gz \
            dist/horizon-source.tar.gz
      - uses: actions/upload-artifact@v7
@@ -206,12 +212,17 @@ jobs:
        with:
          path: dist
          merge-multiple: true
-      - name: The signature, checked as launchers check it
+      - name: The signatures, checked as launchers check them
        env:
          EPHEMERAL: ${{ needs.pick.outputs.dry_run == 'true' && 'yes' || '' }}
+          DATE: ${{ needs.pick.outputs.date }}
+          SHORT: ${{ needs.pick.outputs.short }}
        run: |
          key=(); [[ -n "$EPHEMERAL" ]] && key=(--key "$(cat dist/ephemeral.pub)")
          cargo run --locked --quiet -p horizon-release-sign -- verify --tag nightly --publishing "${key[@]}" dist
+          # The version's own signature, which current launchers require: the title below names the same version.
+          cargo run --locked --quiet -p horizon-release-sign -- verify --tag "nightly-${DATE}-${SHORT}" \
+            --signature SHA256SUMS.v2.sig --publishing "${key[@]}" dist
      - name: Ready to publish (the smoke test drew a world, no release-blocker is open)
        # Right before publishing, as for a release: an issue labelled while the builds ran still holds it. A dry run
        # only reports what a real run would do (that is how a blocker's fix is tried).
@@ -228,12 +239,16 @@ jobs:
        env:
          GH_TOKEN: ${{ github.token }}
          SHA: ${{ needs.pick.outputs.sha }}
+          SHORT: ${{ needs.pick.outputs.short }}
          DATE: ${{ needs.pick.outputs.date }}
          SOURCE_TAG: ${{ needs.pick.outputs.source_tag }}
        run: |
          set -euo pipefail
          python3 tools/ci/nightly.py rotate
          signature=(); [[ -f dist/SHA256SUMS.sig ]] && signature=(dist/SHA256SUMS.sig)
+          [[ -f dist/SHA256SUMS.v2.sig ]] && signature+=(dist/SHA256SUMS.v2.sig)
+          # The title is what launchers parse (strictly) into the version SHA256SUMS.v2.sig is signed for.
+          [[ "${SHA:0:7}" == "$SHORT" ]] || { echo "::error::the build's commit isn't the one signed"; exit 1; }
          # The ARM64 archive only when its build succeeded (the sign job left it out of SHA256SUMS otherwise).
          arm64=()
          if [[ -f dist/horizon-windows-arm64.zip ]]; then
@@ -241,11 +256,18 @@ jobs:
          else
            echo "::warning::horizon-windows-arm64.zip is missing: the Nightly goes out without it (ARM64 launchers install the x64 build)"
          fi
+          musl=()
+          if [[ -f dist/horizon-linux-musl-x86_64.tar.gz ]]; then
+            musl=("dist/horizon-linux-musl-x86_64.tar.gz#Game files for musl Linux (horizon-linux-musl-x86_64.tar.gz)")
+          else
+            echo "::warning::horizon-linux-musl-x86_64.tar.gz is missing: the Nightly goes out without it"
+          fi
          # A pre-release, never GitHub's latest: the latest stays the last vX.Y.Z, which launchers and servers from
          # before the Nightly-only switch keep (they don't read Nightlies).
          gh release create nightly --prerelease --latest=false --target "$SHA" \
            --title "Nightly $DATE · ${SHA:0:7}" --notes-file dist/nightly-notes.md \
            "dist/horizon-linux-x86_64.tar.gz#Game files the launcher installs (Nightly): Linux (horizon-linux-x86_64.tar.gz)" \
+            "${musl[@]}" \
            "dist/horizon-windows-x64.zip#Game files the launcher installs (Nightly): Windows (horizon-windows-x64.zip)" \
            "${arm64[@]}" \
            "dist/horizon-macos-arm64.zip#Game files the launcher installs (Nightly): macOS on Apple Silicon (horizon-macos-arm64.zip)" \
@@ -41,6 +41,8 @@ jobs:
          GH_TOKEN: ${{ github.token }}
          BODY: ${{ github.event.comment.body }}
          AUTHOR: ${{ github.event.comment.user.login }}
+          # Who may act is decided by this numeric ID: a login can be claimed by someone else after a rename.
+          AUTHOR_ID: ${{ github.event.comment.user.id }}
          ISSUE: ${{ github.event.issue.number }}
          COMMENT_URL: ${{ github.event.comment.html_url }}
        run: python3 tools/ci/nightly_set.py command
@@ -20,6 +20,12 @@ on:
          busy the job waits for it.
        type: boolean
        default: false
+      frame_identity:
+        description: >-
+          The pull request carries the frame-identity label: it must leave the picture alone (HDR, shader packs), so
+          the frame_identity harness, which no automatic selection picks, runs too.
+        type: boolean
+        default: false
 permissions:
  contents: read
 env:
@@ -87,6 +93,12 @@ jobs:
          PARITY_HOSTS: ''
          BASE_SHA: ${{ steps.merge.outputs.base }}
        run: python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400  # world_spawn takes ~1480 s on a busy runner
+      - name: The pictures this change must leave alone
+        if: ${{ !cancelled() && inputs.frame_identity }}
+        env:
+          PARITY_HOSTS: ''
+          BASE_SHA: ${{ steps.merge.outputs.base }}
+        run: python3 tools/parity.py frame_identity --timeout 2400
      - name: Logs of the failed harnesses
        if: failure()
        uses: actions/upload-artifact@v7
@@ -27,3 +27,4 @@ jobs:
      base: ${{ github.event.pull_request.base.sha }}
      head: ${{ github.event.pull_request.head.sha }}
      full: ${{ contains(github.event.pull_request.labels.*.name, 'full-parity') }}
+      frame_identity: ${{ contains(github.event.pull_request.labels.*.name, 'frame-identity') }}
@@ -43,6 +43,8 @@ jobs:
          GH_TOKEN: ${{ github.token }}
          BODY: ${{ github.event.comment.body }}
          AUTHOR: ${{ github.event.comment.user.login }}
+          # Who may act is decided by this numeric ID: a login can be claimed by someone else after a rename.
+          AUTHOR_ID: ${{ github.event.comment.user.id }}
          ISSUE: ${{ github.event.issue.number }}
          REPO: ${{ github.repository }}
          COMMENT_URL: ${{ github.event.comment.html_url }}
@@ -9,8 +9,10 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
 - **Never commit Mojang's files**: game jars, assets, decompiled source, prepared resources (`.local/`).
  `tools/check_public_tree.py` rejects them; `git config core.hooksPath .githooks` runs it on commit.
 - **Keep your runs away from real player data.** Any game or launcher you start gets fresh `mktemp -d`
-  folders in `HORIZON_HOME` (the game's data), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and
-  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`, and, for the
+  folders in `HORIZON_HOME` (logs, crash reports, telemetry consent, recordings; not saves), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and
+  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`. Saves, `options.txt` and
+  caches go in the game folder, by default the working directory: start the game from a scratch folder with
+  `--game-dir` pointing at it, or they land in the repo root, hidden by `.gitignore`. For the
  launcher, `HORIZON_LAUNCHER_TRASH`, `HORIZON_LAUNCHER_CLIPBOARD` and `HORIZON_LAUNCHER_DESKTOP` pointing into the scratch home. Never write to
  `~/.local/share/{applications,horizon,horizon-launcher}` or `~/.local/bin`.
 - **Mark what an agent posts.** A PR body starts with a line naming the person whose agent opened it and
@@ -32,7 +34,10 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
 - Contributors first: `gh pr list --state open --search <area>` before you start; never duplicate theirs.
 - **No hardcoded user-facing strings.** Keep UI translation-ready from the start. In the launcher (`launcher/`), wrap visible text with `tr("...")` or `trf("... {arg} ...", &[("arg", &val)])` from `crate::i18n` instead of raw string literals or `format!`. In the game, use translation keys (`Text::tr`, `lang::get`), never hardcoded English strings.
 - **Claim before you start**: comment `/claim` on the issue (no issue yet: open one, then claim it). An assigned
-  issue is taken: pick another. `/unclaim` when you stop; a claim with no open PR linking it is released after 5 days.
+  issue is taken, and so is one labelled `in progress` (claimed on Discord): pick another. `/unclaim` when you stop;
+  a claim with no open PR linking it is released after 5 days. The issues free to claim, without reading threads:
+  `gh issue list --search 'is:open no:assignee -label:"in progress" -label:tracker -label:proposal -label:"not claimable" -linked:pr'`
+- **Controllers reach what registers.** Draw controls with a registering helper (`ui::button`, `settings_shell::foot_button`); `graphics_style::button` and `screen_draw::button` only paint, and registering one part of a screen ends its crosshair, so register all of it.

 ## Crates

@@ -147,6 +147,12 @@ dependencies = [
 "x11rb",
 ]

+[[package]]
+name = "arcstr"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03918c3dbd7701a85c6b9887732e2921175f26c350b4563841d0958c21d57e6d"
+
 [[package]]
 name = "arrayref"
 version = "0.3.9"
@@ -303,6 +309,21 @@ dependencies = [
 "objc2 0.6.5",
 ]

+[[package]]
+name = "btoi"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b5ab9db53bcda568284df0fd39f6eac24ad6f7ba7ff1168b9e76eba6576b976"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "bufstream"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40e38929add23cdf8a366df9b0e088953150724bcbe5fc330b0d8eb3b328eec8"
+
 [[package]]
 name = "bumpalo"
 version = "3.20.3"
@@ -329,6 +350,12 @@ dependencies = [
 "syn 3.0.6",
 ]

+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
 [[package]]
 name = "byteorder-lite"
 version = "0.1.0"
@@ -651,6 +678,15 @@ dependencies = [
 "cfg-if",
 ]

+[[package]]
+name = "crossbeam-queue"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03e8bd762f7479489c70ed6c768ddca99d7296857de437a68dcb2a94365b3fae"
+dependencies = [
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.23"
@@ -768,6 +804,17 @@ version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e9de72ce2ad1f90dc62fa25f0f430ef85eb4b0d8fa0be4f30373bc40a21d28e"

+[[package]]
+name = "derive_utils"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc05a5d33db20c784f873e84934ad94bb209a090987ac5f62fede2c178234f23"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+
 [[package]]
 name = "des"
 version = "0.8.1"
@@ -1318,6 +1365,7 @@ dependencies = [
 "ab_glyph",
 "bytemuck",
 "chrono",
+ "dunce",
 "flate2",
 "fs4",
 "gilrs",
@@ -1363,6 +1411,7 @@ dependencies = [
 "serde_json",
 "sha1",
 "sha2",
+ "toml",
 "unicode-bidi",
 "ureq",
 "wgpu",
@@ -1400,6 +1449,7 @@ dependencies = [
 "chrono",
 "flate2",
 "fs4",
+ "getrandom 0.3.4",
 "gilrs",
 "glam",
 "horizon-anticheat",
@@ -1411,6 +1461,7 @@ dependencies = [
 "horizon-client-render",
 "horizon-command",
 "horizon-core",
+ "horizon-cosmetics",
 "horizon-dualsense",
 "horizon-friends",
 "horizon-hdr",
@@ -1605,6 +1656,16 @@ dependencies = [
 "serde_json",
 ]

+[[package]]
+name = "horizon-mod-deps"
+version = "0.1.0"
+dependencies = [
+ "mysql",
+ "redis",
+ "rusty-opus",
+ "tungstenite",
+]
+
 [[package]]
 name = "horizon-mods"
 version = "0.1.0"
@@ -1715,6 +1776,7 @@ dependencies = [
 "horizon-mcp",
 "horizon-release-sign",
 "horizon-server-files",
+ "horizon-world",
 "libc",
 "p12-keystore",
 "png",
@@ -1999,6 +2061,15 @@ dependencies = [
 "generic-array",
 ]

+[[package]]
+name = "io-enum"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f859dc81e05e585e93cfc84dffa4fd068d0651ca229c51bca6101c056b63b93a"
+dependencies = [
+ "derive_utils",
+]
+
 [[package]]
 name = "ipconfig"
 version = "0.3.4"
@@ -2246,6 +2317,12 @@ version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"

+[[package]]
+name = "lru"
+version = "0.16.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f66e8d5d03f609abc3a39e6f08e4164ebf1447a732906d39eb9b99b7919ef39"
+
 [[package]]
 name = "lz4_flex"
 version = "0.14.0"
@@ -2335,6 +2412,59 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "743fb55ba31b18fb1ecef6bdc9aa2743314978ac084044301a7eee33fb99a20d"

+[[package]]
+name = "mysql"
+version = "27.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "090068bc0a24762663338da78414148333d1ee246a7293c10a517ddf1548b291"
+dependencies = [
+ "bufstream",
+ "bytes",
+ "crossbeam-queue",
+ "crossbeam-utils",
+ "flate2",
+ "io-enum",
+ "libc",
+ "lru",
+ "mysql_common",
+ "named_pipe",
+ "pem",
+ "percent-encoding",
+ "rustls",
+ "rustls-pemfile",
+ "socket2 0.6.5",
+ "twox-hash",
+ "url",
+ "webpki",
+ "webpki-roots 1.0.10",
+]
+
+[[package]]
+name = "mysql_common"
+version = "0.36.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20e7f6a15265801679ddf1ddb38fd74b4555a677a78378d4561fbe5f0b1d4d72"
+dependencies = [
+ "base64",
+ "bitflags 2.13.2",
+ "btoi",
+ "byteorder",
+ "bytes",
+ "crc32fast",
+ "flate2",
+ "getrandom 0.3.4",
+ "num-bigint",
+ "num-traits",
+ "regex",
+ "saturating",
+ "serde",
+ "serde_json",
+ "sha1",
+ "sha2",
+ "thiserror 2.0.21",
+ "uuid",
+]
+
 [[package]]
 name = "naga"
 version = "30.0.1"
@@ -2372,6 +2502,15 @@ dependencies = [
 "thiserror 2.0.21",
 ]

+[[package]]
+name = "named_pipe"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad9c443cce91fc3e12f017290db75dde490d685cdaaf508d7159d7cf41f0eb2b"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "ndk"
 version = "0.9.0"
@@ -2971,6 +3110,16 @@ dependencies = [
 "hmac",
 ]

+[[package]]
+name = "pem"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d30c53c26bc5b31a98cd02d20f25a7c8567146caf63ed593a9d87b2775291be"
+dependencies = [
+ "base64",
+ "serde_core",
+]
+
 [[package]]
 name = "pem-rfc7468"
 version = "0.7.0"
@@ -3298,6 +3447,22 @@ dependencies = [
 "yasna",
 ]

+[[package]]
+name = "redis"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db7f3d75b5a3301746bff39a767bf4c5c42506b08513527308b3875bfb64a031"
+dependencies = [
+ "arcstr",
+ "combine",
+ "itoa",
+ "percent-encoding",
+ "ryu",
+ "socket2 0.6.5",
+ "url",
+ "xxhash-rust",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.4.1"
@@ -3439,6 +3604,15 @@ dependencies = [
 "zeroize",
 ]

+[[package]]
+name = "rustls-pemfile"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
+dependencies = [
+ "rustls-pki-types",
+]
+
 [[package]]
 name = "rustls-pki-types"
 version = "1.15.1"
@@ -3465,6 +3639,12 @@ version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"

+[[package]]
+name = "rusty-opus"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46604e6809c06441da1cfdde1f0cc25a4f2bf42c7d005aa387c2875c02d78762"
+
 [[package]]
 name = "ruzstd"
 version = "0.9.1"
@@ -3474,6 +3654,12 @@ dependencies = [
 "twox-hash",
 ]

+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
 [[package]]
 name = "salsa20"
 version = "0.10.2"
@@ -3492,6 +3678,12 @@ dependencies = [
 "winapi-util",
 ]

+[[package]]
+name = "saturating"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ece8e78b2f38ec51c51f5d475df0a7187ba5111b2a28bdc761ee05b075d40a71"
+
 [[package]]
 name = "scoped-tls"
 version = "1.0.1"
@@ -3711,6 +3903,17 @@ dependencies = [
 "windows-sys 0.61.2",
 ]

+[[package]]
+name = "socks"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0c3dbbd9ae980613c6dd8e28a9407b50509d3803b57624d5dfe8315218cd58b"
+dependencies = [
+ "byteorder",
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "spake2"
 version = "0.4.0"
@@ -4089,6 +4292,18 @@ version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"

+[[package]]
+name = "tungstenite"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e48ac77174b19c110a50ab2128b24215ac9cb40e0e12e093fb602d175c569d22"
+dependencies = [
+ "bytes",
+ "log",
+ "rand",
+ "thiserror 2.0.21",
+]
+
 [[package]]
 name = "twox-hash"
 version = "2.1.5"
@@ -4164,6 +4379,7 @@ dependencies = [
 "once_cell",
 "rustls",
 "rustls-pki-types",
+ "socks",
 "url",
 "webpki-roots 0.26.11",
 ]
@@ -4431,6 +4647,16 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "webpki"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
 [[package]]
 name = "webpki-roots"
 version = "0.26.11"
@@ -4626,6 +4852,22 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"

+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
 [[package]]
 name = "winapi-util"
 version = "0.1.11"
@@ -4635,6 +4877,12 @@ dependencies = [
 "windows-sys 0.61.2",
 ]

+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
 [[package]]
 name = "windows"
 version = "0.54.0"
@@ -39,6 +39,7 @@ members = [
    "crates/horizon-optifine",
    "crates/horizon-shader-api",
    "crates/horizon-release-sign",
+    "crates/horizon-mod-deps",
    "xtask",
 ]
 resolver = "2"
@@ -1,77 +1,87 @@
 <p align="center">
-  <img src="docs/media/banner.webp" alt="The Horizon website: the game you know, rebuilt in Rust" width="100%">
-</p>
-
-<p align="center">
-  <a href="https://github.com/horizon-rust/horizon/actions/workflows/ci.yml"><img src="https://github.com/horizon-rust/horizon/actions/workflows/ci.yml/badge.svg?branch=main" alt="CI"></a>
-  <img src="https://img.shields.io/badge/Minecraft-Java%2026.3-5D9C3F" alt="Minecraft Java 26.3">
-  <img src="https://img.shields.io/badge/Rust-stable-B7410E?logo=rust&logoColor=white" alt="Rust">
-  <img src="https://img.shields.io/badge/vanilla%20parity-100%25-F0795A" alt="Vanilla parity 100%">
-  <a href="#project-status"><img src="https://img.shields.io/badge/player--visible%20gaps-0%20open-F0795A" alt="Player-visible gaps open"></a>
-  <img src="https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20Windows-2A2470" alt="Linux, macOS and Windows">
-  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-3B2F7E" alt="MIT license"></a>
+  <img src="docs/media/banner.webp" alt="Horizon: the game you know, rebuilt in Rust" width="100%">
 </p>

 <p align="center">
  <a href="https://playhorizon.dev"><b>Website</b></a> ·
  <a href="#download"><b>Download</b></a> ·
-  <a href="https://playhorizon.dev/docs/"><b>Documentation</b></a> ·
-  <a href="https://github.com/horizon-rust/horizon/releases"><b>Release notes</b></a> ·
+  <a href="https://playhorizon.dev/docs/"><b>Docs</b></a> ·
+  <a href="https://discord.gg/playhorizon"><b>Discord</b></a> ·
  <a href="ROADMAP.md"><b>Roadmap</b></a> ·
-  <a href="#project-status"><b>Project status</b></a> ·
  <a href="#contributing"><b>Contributing</b></a>
 </p>

+<p align="center">
+  <img src="https://img.shields.io/badge/vanilla%20parity-100%25-F0795A" alt="Vanilla parity 100%">
+  <a href="#project-status"><img src="https://img.shields.io/badge/player--visible%20gaps-0%20open-F0795A" alt="Player-visible gaps open"></a>
+</p>
+
 # Horizon

-Minecraft: Java Edition 26.3, rewritten in Rust. Same worlds, same rules, same terrain, checked against the Java game by more than 300 differential harnesses. Free, open source and unofficial.
+**Minecraft: Java Edition 26.3, rewritten in Rust.** Your worlds, the same rules and the same terrain as the Java game, checked against it by hundreds of differential tests, in one native program with no Java. Free, open source (MIT) and unofficial: you play it with your own copy of Java Edition.

-> Not an official Minecraft product, nor approved by or associated with Mojang or Microsoft. Horizon contains no Minecraft code, assets or data: you need your own copy of Java Edition 26.3.
-
-## Download
-
-Get **the Horizon launcher** from [playhorizon.dev](https://playhorizon.dev) or [the launcher releases](https://github.com/horizon-rust/horizon/releases?q=launcher-v&expanded=true) (Linux x86-64, macOS on Apple Silicon, macOS on Intel from the next Nightly, Windows x64). It installs and updates the game, prepares its files from your copy of Minecraft, and updates itself.
-
-**You need** a Microsoft account that owns Java Edition ([why](docs/microsoft-account.md)) and a GPU with Vulkan or OpenGL 3.3 (Linux), Vulkan or DirectX 12 (Windows), or a Mac (Apple Silicon, or Intel from the next Nightly). An existing Minecraft install (official launcher, Prism, MultiMC...) is reused; without one, Play downloads 26.3 from Mojang for your account. Step by step: [Install and first launch](https://playhorizon.dev/docs/install).
-
-<table>
-  <tr>
-    <td width="50%"><img src="docs/media/launcher-play.webp" alt="The launcher's Home page: the selected instance ready to play, the version picker, Join a friend and the instance's tabs"></td>
-    <td width="50%"><img src="docs/media/launcher-settings.webp" alt="The launcher's Settings page: Microsoft account, offline name, updates, appearance and accent colour"></td>
-  </tr>
-</table>
+<p align="center">
+  <img src="docs/media/readme/valley.webp" alt="A river valley with a plains village, savanna hills and a cherry grove, seen from above with a long view distance" width="100%">
+</p>

 ## What works today

- **The game:** vanilla world generation, mobs, villagers, raids, redstone, every command, the HUD and the recipe book, on vanilla saves. Worlds from 1.8 to 26.2 are upgraded. [Status](#project-status).
- **Extras:** new menus, graphics presets, distant terrain up to 1024 chunks, controllers, zoom, minimap and more, off by default where they change the vanilla look. [Settings](https://playhorizon.dev/docs/settings).
- **Packs:** resource packs, and data packs with functions, predicates, item modifiers and world generation.
- **Multiplayer:** invite friends with a code, Open to LAN, join servers (online mode included). [Multiplayer](https://playhorizon.dev/docs/multiplayer).
- **Mods:** content mods (blocks, items, data) and native Rust mods, built by the launcher with nothing to install. Java mod jars do not run. [Mods](https://playhorizon.dev/docs/mods).
+Everything below is in the current release.

-In the Rust client, with vanilla assets and no mods or shaders:
+- **The game.** Survival, creative, hardcore and spectator; vanilla world generation in all three dimensions, mobs, villagers, raids, redstone, every command, the HUD and the recipe book. Vanilla saves open as they are, and worlds from 1.8 to 26.2 are upgraded.
+- **Multiplayer.** Join vanilla and Horizon servers (online mode included), open a world to LAN, or invite friends with a code from the launcher's Home page.
+- **Graphics.** Distant terrain up to 1,024 chunks, graphics presets, HDR and controllers, all off by default where they would change the vanilla look ([settings](https://playhorizon.dev/docs/settings)).
+- **Packs.** Resource packs, data packs and shader packs ([below](#mods-and-shader-packs)).
+- **Mods.** Content mods and native Rust mods, installed from the launcher ([below](#mods-and-shader-packs)).
+- **Servers.** Host one from the launcher, or run `horizon-server` on a VPS ([below](#host-a-server)).
+- **The launcher.** It installs and updates the game, prepares its files from your copy of Minecraft, and updates itself.

 <table>
  <tr>
-    <td colspan="2"><img src="docs/media/sunset.webp" alt="Sunset over a savanna river valley and a plains village"></td>
+    <td width="50%"><img src="docs/media/readme/sunset.webp" alt="Sunset behind a cherry grove on a hill, with a river below"></td>
+    <td width="50%"><img src="docs/media/readme/nether.webp" alt="A crimson forest in the Nether, with a piglin among the fungi"></td>
  </tr>
  <tr>
-    <td width="50%"><img src="docs/media/survival.webp" alt="Survival at dusk: a zombie walks up, with the hotbar, health, hunger and experience"></td>
-    <td width="50%"><img src="docs/media/settings.webp" alt="Vanilla's Video Settings screen with Horizon's own buttons at the top: Horizon Graphics and Advanced Graphics"></td>
-  </tr>
-  <tr>
-    <td width="50%"><img src="docs/media/village.webp" alt="A plains village among savanna hills, with farms, villagers and an iron golem"></td>
-    <td width="50%"><img src="docs/media/nether.webp" alt="A crimson forest in the Nether with a zombified piglin"></td>
+    <td width="50%"><img src="docs/media/readme/survival.webp" alt="Survival in a village square: two villagers, flowers, the hotbar, health and hunger"></td>
+    <td width="50%"><img src="docs/media/readme/multiplayer.webp" alt="Two players in a LAN world: the other player's name tag and the player list"></td>
  </tr>
 </table>

+<sub>Nightly 2026-11-05 on a Mac mini (Apple M4 Pro, Metal): vanilla's textures, no mods or shader packs, render distance 32 with distant terrain on.</sub>
+
+## Download
+
+Get **the Horizon launcher** from [playhorizon.dev](https://playhorizon.dev), or from [the launcher releases](https://github.com/horizon-rust/horizon/releases?q=launcher&expanded=true):
+
+| Platform | File | Needs |
+| --- | --- | --- |
+| Windows x64 | `horizon-launcher-setup.exe` | Windows 10 or 11, a GPU with Vulkan or DirectX 12 |
+| Windows on Arm | `horizon-launcher-setup-arm64.exe` | Windows 11 on Arm |
+| macOS, Apple Silicon | `horizon-launcher-macos-arm64.dmg` | macOS 12 or later |
+| macOS, Intel | `horizon-launcher-macos-x64.dmg` | macOS 12 or later |
+| Linux x86-64 | `horizon-launcher-linux-x86_64.AppImage` or `.tar.gz` | a glibc distribution, X11 or Wayland, a GPU with Vulkan or OpenGL 3.3 |
+
+**You also need a Microsoft account that owns Minecraft: Java Edition.** You sign in with it in the launcher, which plays only with an account that owns the game ([why](docs/microsoft-account.md)). Horizon contains no Minecraft code or assets: an existing install (official launcher, Prism, MultiMC...) is reused, and without one the launcher downloads 26.3 from Mojang for your account. Step by step: [Install and first launch](https://playhorizon.dev/docs/install).
+
+<table>
+  <tr>
+    <td width="50%"><img src="docs/media/readme/launcher-home.webp" alt="The launcher's Home page: the Horizon instance, Play, the version picker, the friend invite field, screenshots and the patch log"></td>
+    <td width="50%"><img src="docs/media/readme/launcher-mods.webp" alt="The launcher's Mods page: Horizon's mod registry with Zoom selected, and tabs for modpacks, resource packs, shader packs and data packs"></td>
+  </tr>
+</table>
+
+## Mods and shader packs
+
+- **Content mods** (`.hmod`): blocks, items, recipes, loot, models and textures, with no code.
+- **Native mods** (`.hnmod`): Rust that the launcher compiles into the game for you, with nothing to install.
+- **Java mods** (Fabric, NeoForge, Forge) don't run: Horizon has no Java. The launcher carries over the data and assets inside their jars, and imports modpacks (`.mrpack`, CurseForge zips, Prism instances) the same way ([modpacks](https://playhorizon.dev/docs/modpacks)).
+- **Shader packs**: Iris/OptiFine-format packs (`shaders/` folders) and Horizon's own WGSL packs, under Video Settings → Shader Packs ([pack format](docs/shaders.md)).
+
+Mods are off by default: a fresh install plays exactly like vanilla 26.3. The launcher's Mods page browses Horizon's registry and Modrinth. [Mods](https://playhorizon.dev/docs/mods) · [make a mod](docs/mods.md).
+
 ## Host a server

-The launcher's **Servers** page creates, starts, backs up and updates a server, and invites friends over Tailscale. On a VPS, `horizon-server` installs with one command and needs no Java. [Host a server](https://playhorizon.dev/docs/hosting) ([reference](docs/hosting.md)).
-
-## Modpacks
-
-The launcher imports Modrinth and CurseForge packs and plays the mods Horizon can carry over: today, content mods made of data and assets, not Java code. [Modpacks](https://playhorizon.dev/docs/modpacks).
+The launcher's **Servers** page creates, starts, backs up and updates a server, and invites friends. On a VPS, `horizon-server` installs with one command, needs no Java, and takes vanilla 26.3 and Horizon players alike. [Host a server](https://playhorizon.dev/docs/hosting) ([reference](docs/hosting.md)).

 ## Agent control

@@ -80,13 +90,11 @@ AI agents and scripts can play Horizon. `horizon-ctl`, shipped with the game, re
 ```sh
 horizon-ctl launch --world Survival --seed 5 --wait   # finds the version the launcher installed
 horizon-ctl state                                       # position, health, food, target, screen...
-horizon-ctl find-block birch_log                        # the nearest logs
 horizon-ctl goto -0.5 65 -2.5 --near 2.5                # walks there along a path
 horizon-ctl break -1 65 -3                              # mines it; replies with the drops
-horizon-ctl open-inventory && horizon-ctl click-slot 0  # menus: slots, buttons by label, text fields
 ```

-Commands block until done and reply with the result; `horizon-ctl help` lists them all. [Agent control](docs/native-client.md#agent-control-horizon-ctl-and-mcp).
+`horizon-ctl help` lists every command. [Agent control](docs/native-client.md#agent-control-horizon-ctl-and-mcp).

 ## Build from source

@@ -105,13 +113,9 @@ cargo run --release -p horizon-client

 Prepared files land in the gitignored `.local/`: never commit or share them. Options, controls and architecture: [the native client guide](docs/native-client.md); all developer docs: [docs/README.md](docs/README.md).

-## Roadmap
-
-What is in progress, what comes next and where to help: [ROADMAP.md](ROADMAP.md), or [playhorizon.dev/hub](https://playhorizon.dev/hub) with the work board and what shipped.
-
 ## Contributing

-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:
+Issues and pull requests are welcome: read [CONTRIBUTING.md](CONTRIBUTING.md) (vanilla first, small pull requests), and see [ROADMAP.md](ROADMAP.md) or [playhorizon.dev/hub](https://playhorizon.dev/hub) for what's next. Questions: [Discord](https://discord.gg/playhorizon). Before a pull request, run the self-check and paste its output:

 ```sh
 git config core.hooksPath .githooks
@@ -124,7 +128,7 @@ It runs rustfmt, clippy, the touched crates' tests, the Python tests, the public

 **Player-visible gaps: 0 open** of the 833 the [port ledger](tools/port_ledger.py) found, reading every vanilla 26.3 method against Horizon's code: vanilla behaviour a player would notice that Horizon doesn't have yet. By area: Animals [0](https://github.com/horizon-rust/horizon/issues/3512); Monsters and bosses [0](https://github.com/horizon-rust/horizon/issues/3513); Entities, projectiles, vehicles and decorations [0](https://github.com/horizon-rust/horizon/issues/3514); Items, enchantments and inventories [0](https://github.com/horizon-rust/horizon/issues/3515); Blocks, redstone and fluids [0](https://github.com/horizon-rust/horizon/issues/3516); World, world generation and saves [0](https://github.com/horizon-rust/horizon/issues/3517); Screens, HUD and client packets [0](https://github.com/horizon-rust/horizon/issues/3518); Entity and block rendering, models [0](https://github.com/horizon-rust/horizon/issues/3519); Server and players on the server [0](https://github.com/horizon-rust/horizon/issues/3520); Mob AI, villagers and raids [0](https://github.com/horizon-rust/horizon/issues/3521). This number goes down as gaps close (`tools/parity_gaps.py`); the harness results below say that what is tested matches.

-The table is the project's own audit: every subsystem matches vanilla in every harness that compares it. 100% means 100% of what the harnesses compare, not that nothing else differs.
+The table is the project's own audit: every subsystem matches vanilla in every harness that compares it. 100% means 100% of what the harnesses compare, not that nothing else differs. What players still run into: [known issues](docs/known-issues.md).

 ### Java parity: 100%

@@ -147,14 +151,8 @@ Scores: 0 (absent), 0.25 (started), 0.5 (playable, major features missing), 0.75
 | Audio | 1 | None: the sound engine, sound events, music, situational music, ambience and subtitles match vanilla |
 | Block behaviours and ticking | 1 | None: block updates, random ticks, redstone, dispensers (6,000 cases), crafters (4,000), container spills (4,000), copper golems and the sculk family (435 scenarios) match |

-### Known issues
-
-Skins served over https show the default skin unless already cached; pack icons show the unknown-pack texture in game; item tooltips lack attribute lines.
-
 ## Licence

-[MIT](LICENSE), for the project's original work; dependencies keep their own licences ([notices](THIRD_PARTY_NOTICES.md)). Minecraft is a trademark of Mojang Synergies AB; its code and assets belong to Mojang and Microsoft under the [Minecraft EULA](https://www.minecraft.net/en-us/eula).
+[MIT](LICENSE), for the project's original work; dependencies keep their own licences ([notices](THIRD_PARTY_NOTICES.md)). Horizon is made by [Ludovic Marie](https://lu4ovic.com) ([@ludovic111](https://github.com/ludovic111)) and [its contributors](https://github.com/horizon-rust/horizon/graphs/contributors); support it on [GitHub Sponsors](https://github.com/sponsors/ludovic111).

-## Author
-
-Made by [Ludovic Marie](https://lu4ovic.com) ([@ludovic111](https://github.com/ludovic111)).
+NOT AN OFFICIAL MINECRAFT PRODUCT. NOT APPROVED BY OR ASSOCIATED WITH MOJANG OR MICROSOFT. Minecraft is a trademark of Mojang Synergies AB; its code and assets belong to Mojang and Microsoft under the [Minecraft EULA](https://www.minecraft.net/en-us/eula).
@@ -206,7 +206,7 @@ Manage a server from a console, ban and pardon players, and drive it from other

 <details><summary>Technical</summary>

-`horizon-server console` (a text interface), `ban`, `pardon`, `ban-ip` and `mcp` over stdio. Admin API additions: the player list, kick, ban, op and whitelist, an SSE stream of logs and events, a text metrics endpoint, config GET and PATCH, backup delete and download. The panel's later features (bans, worlds, server.properties import, logs and crash reports, modpacks) and vanilla's management protocol (the JSON-RPC over WebSocket that the `management-server-*` keys configure), so vanilla's tools can manage a Horizon server. [docs/server.md](docs/server.md), [docs/api/server.md](docs/api/server.md).
+`horizon-server console` (a text interface), `ban`, `pardon`, `ban-ip` and `mcp` over stdio. Admin API additions: the player list, kick, ban, op and whitelist, an SSE stream of logs and events, a text metrics endpoint, config GET and PATCH, backup delete and download. The last pieces merged: bans edited while the server is stopped ([#9767](https://github.com/horizon-rust/horizon/issues/9767)) and the MCP tools' contracts pinned by a test ([#9748](https://github.com/horizon-rust/horizon/issues/9748)). The panel's later features and vanilla's management protocol are their own item (server-panel-management). [docs/server.md](docs/server.md), [docs/api/server.md](docs/api/server.md).

 </details>

@@ -266,7 +266,7 @@ Shader packs were removed and are being rebuilt from scratch. They come back, of

 A clean-room rewrite in `horizon-shaderpack`, from the packs' public format documentation only: reading packs, the preprocessor and `.properties` files are merged ([#1584](https://github.com/horizon-rust/horizon/issues/1584), [#1585](https://github.com/horizon-rust/horizon/issues/1585), [#1586](https://github.com/horizon-rust/horizon/issues/1586)); translating programs to WGSL through naga, buffers, uniforms and the terrain, entity, sky, weather and hand stages are in review ([#1698](https://github.com/horizon-rust/horizon/issues/1698) to [#1801](https://github.com/horizon-rust/horizon/issues/1801)).

-More: [#1561](https://github.com/horizon-rust/horizon/issues/1561) · [#1771](https://github.com/horizon-rust/horizon/issues/1771) · [#1786](https://github.com/horizon-rust/horizon/issues/1786)
+More: [#1561](https://github.com/horizon-rust/horizon/issues/1561) · [#1771](https://github.com/horizon-rust/horizon/issues/1771) · [#1786](https://github.com/horizon-rust/horizon/issues/1786) · [#9045](https://github.com/horizon-rust/horizon/issues/9045) · [#6233](https://github.com/horizon-rust/horizon/issues/6233) · [#6485](https://github.com/horizon-rust/horizon/issues/6485) · [#3734](https://github.com/horizon-rust/horizon/issues/3734) · [#3125](https://github.com/horizon-rust/horizon/issues/3125)

 </details>

@@ -298,6 +298,8 @@ Far terrain drawn from the world you really built and explored, caves and builds

 Keep a 3D mip store on disk built from real chunks, drawn by the GPU beside the seed preview for areas nobody has visited. Written from scratch and measured before it is kept. Builds on Far Detail and the far-terrain levels of detail already shipped; the open work on them is [#718](https://github.com/horizon-rust/horizon/issues/718).

+More: [#4678](https://github.com/horizon-rust/horizon/issues/4678)
+
 </details>

 #### A batch of targeted optimisations
@@ -308,7 +310,7 @@ Several smaller speed-ups, each measured: idle block entities that sleep, cheape

 Block entities and hoppers that skip work when idle (the hopper item scan is already skipped when no item is near); a particle frustum test first (also a parity gap), then particle quads built on the GPU; jigsaw shortcuts that skip blocked connectors and pool elements known not to fit, with layouts unchanged (trial chambers and ancient cities first); batched raw mouse input on Windows for 8000 Hz mice; a better atlas packer for huge resource packs (a 64x pack builds a 704 MiB atlas for 452 MiB of textures); sign-heavy scenes ([#1461](https://github.com/horizon-rust/horizon/issues/1461)). Profile first, keep what pays, show before and after numbers.

-More: [docs/profiling.md](docs/profiling.md)
+More: [docs/profiling.md](docs/profiling.md) · [#7752](https://github.com/horizon-rust/horizon/issues/7752) · [#8251](https://github.com/horizon-rust/horizon/issues/8251) · [#10229](https://github.com/horizon-rust/horizon/issues/10229)

 </details>

@@ -322,6 +324,8 @@ Recognise mods built for versions before 26.1 in the mod browser, so they can be

 A mapping table from intermediary and SRG names so pre-26.1 jars can be classified, and a rename for mod ids with dashes (`fabric-api`); the port step then treats them like newer jars ([docs/mod-browser.md](docs/mod-browser.md)).

+More: [#10262](https://github.com/horizon-rust/horizon/issues/10262)
+
 </details>

 #### A modpack's own resource and shader packs
@@ -396,6 +400,16 @@ A Datapacks tab beside Mods and Resource packs: install into a chosen world's da

 ### Servers and multiplayer

+#### Server panel extras and vanilla's management protocol
+
+More of a server managed from its web panel (bans, worlds, logs and crash reports, modpacks), and vanilla's own server-management tools working with a Horizon server.
+
+<details><summary>Technical</summary>
+
+The panel's later features (bans, worlds, server.properties import, logs and crash reports, modpacks) and vanilla's management protocol (the JSON-RPC over WebSocket that the `management-server-*` keys configure), so vanilla's tools can manage a Horizon server. Split from server-admin. [docs/server.md](docs/server.md), [docs/api/server.md](docs/api/server.md).
+
+</details>
+
 #### Ely.by and other sign-in providers

 Sign in with other account providers, such as Ely.by or any Yggdrasil-compatible one, beside Microsoft.
@@ -526,6 +540,8 @@ Contraptions and physics like the Create and Aeronautics mods, as a mod for Hori

 Issue [#805](https://github.com/horizon-rust/horizon/issues/805) (porting QOL mods) closed with this answer: it would come as a native Horizon mod.

+More: [#6302](https://github.com/horizon-rust/horizon/issues/6302) · [#5313](https://github.com/horizon-rust/horizon/issues/5313) · [#5556](https://github.com/horizon-rust/horizon/issues/5556)
+
 </details>

 #### Proximity voice chat as a native mod
@@ -548,6 +564,8 @@ Every past and future Minecraft version prepared for Horizon automatically. When

 The port pipeline ([docs/version-ports.md](docs/version-ports.md), `tools/version_port.py`) detects a release, prepares it, diffs its classes against the pinned 26.3, regenerates the data-driven tables, runs every parity harness on it and writes a port report that becomes issues. The goal is as little human work as possible for any version, past or future. Detection and the first slices are merged; the scheduled agent that runs it every day isn't installed yet. Two versions in one build are out of scope.

+More: [#4758](https://github.com/horizon-rust/horizon/issues/4758)
+
 </details>

 #### Controllers: tested on real pads, and in the launcher
@@ -558,6 +576,8 @@ Make controller support solid: tested with real PlayStation and Xbox pads and a

 The game side is merged ([docs/controllers.md](docs/controllers.md)): pads read with gilrs, menus, rumble, glyphs, remapping and DualSense adaptive triggers, lightbar and haptics, but not yet confirmed on real pads or a Steam Deck (DualSense haptics stay behind a switch until then). Left: a test pass on real hardware, and the same focus navigation in the GPUI launcher.

+More: [#10298](https://github.com/horizon-rust/horizon/issues/10298) · [#8678](https://github.com/horizon-rust/horizon/issues/8678)
+
 </details>

 #### The full debug screen
@@ -600,16 +620,6 @@ An output device list in Music & Sounds, falling back to the system default. [#1

 </details>

-#### Play in your language
-
-Item names, container titles and server messages follow the language you pick, as in vanilla. Today parts of the game stay in English.
-
-<details><summary>Technical</summary>
-
-Translatable components resolved through the selected language for items, containers and server text ([#1806](https://github.com/horizon-rust/horizon/issues/1806)), on top of the bundled languages the prepared resources carry ([#1594](https://github.com/horizon-rust/horizon/issues/1594)). Left: the client's own screens ([#1672](https://github.com/horizon-rust/horizon/issues/1672)) and the main menu with zh_cn.
-
-</details>
-
 ### Rendering

 #### A light default shader pack
@@ -668,6 +678,16 @@ A shared resource store keyed by the preparer's digest, no prepare intermediates

 </details>

+#### A launcher screen readers can read
+
+Screen readers read the launcher's buttons, lists and settings, and every part of it works from the keyboard.
+
+<details><summary>Technical</summary>
+
+Issue [#4537](https://github.com/horizon-rust/horizon/issues/4537): the launcher is GPUI (not Electron), so it exposes nothing to UI Automation, NSAccessibility or AT-SPI yet. Needs an accessibility tree from GPUI (an AccessKit bridge) and a role and label on each widget.
+
+</details>
+
 #### A visible beta label

 A clear 'beta' label in the launcher and the game, so nobody is surprised that Horizon is still being built.
@@ -690,6 +710,18 @@ Issue [#1709](https://github.com/horizon-rust/horizon/issues/1709): aarch64 buil

 </details>

+#### The launcher builds Horizon on other systems
+
+On a system Horizon has no download for, such as FreeBSD, the launcher offers to build the game on your computer, as it already does for native mods.
+
+<details><summary>Technical</summary>
+
+Issue [#4354](https://github.com/horizon-rust/horizon/issues/4354): when no release asset matches the platform, the launcher fetches the tagged source and runs the same pinned-toolchain `cargo build --locked` its native-mod builds use, with a warning about the time it takes. The build is unsigned, so the launcher marks the version as built locally.
+
+More: [docs/native-mods.md](docs/native-mods.md)
+
+</details>
+
 #### Horizon on Windows ARM64

 A native Horizon for Windows on ARM computers, such as Snapdragon laptops.
@@ -710,6 +742,8 @@ Versions of Horizon for Android, iOS and web browsers. Nothing official yet; con

 No official build. Android was first closed as not planned, with touch controls, a mobile interface, packaging and loading the player's own assets all missing; the roadmap now includes it, iOS and a build for the browser as long-term goals. First pieces from contributors: `horizon-dualsense` compiling on iOS ([#1813](https://github.com/horizon-rust/horizon/issues/1813)) and helper-thread limits on Android ([#1751](https://github.com/horizon-rust/horizon/issues/1751)). Preparing without Java ([#1750](https://github.com/horizon-rust/horizon/issues/1750)) matters here too. Horizon ships none of Mojang's files on any platform.

+More: [#9134](https://github.com/horizon-rust/horizon/issues/9134) · [#8069](https://github.com/horizon-rust/horizon/issues/8069) · [#4153](https://github.com/horizon-rust/horizon/issues/4153)
+
 </details>

 #### Horizon on Intel Macs
@@ -752,6 +786,8 @@ Record, replay and edit videos without leaving the game: record in a keypress, r

 Three stages. Recording: capture gameplay in a keypress with an encoder thread and little frame-time cost. Replay: a replay mode for recorded sessions. Editing: cuts, camera paths, titles and export. None of it exists yet; the agent-control socket ([docs/agent-control.md](docs/agent-control.md)) already lets tools drive the game for scripted shots.

+More: [#10025](https://github.com/horizon-rust/horizon/issues/10025)
+
 </details>

 #### Game menus in the launcher's style
@@ -842,6 +878,8 @@ Every download Horizon makes is checked against the project's signature, includi

 Releases carry signed checksums, and the launcher and `horizon-server update` refuse anything unsigned ([#1011](https://github.com/horizon-rust/horizon/issues/1011), [#1014](https://github.com/horizon-rust/horizon/issues/1014)). Left: the first install through `install.sh` and `install.ps1` still trusts only the checksum GitHub publishes, because verifying Ed25519 signatures needs OpenSSL 3, which macOS doesn't ship ([docs/security.md](docs/security.md)).

+More: [#10354](https://github.com/horizon-rust/horizon/issues/10354)
+
 </details>

 ## Help wanted
@@ -860,30 +898,11 @@ More: [https://playhorizon.dev/docs/performance](https://playhorizon.dev/docs/pe

 </details>

-### Gameplay parity
-
-#### End city banners keep their pattern
-
-Banners in End cities show as plain magenta instead of with their pattern.
-
-<details><summary>Technical</summary>
-
-Compare the banner block entities the End city templates place with vanilla's (`EndCityPieces`, the templates' block entity NBT, `BannerBlockEntity`'s patterns), in `crates/horizon-world/src/worldgen/structure/`. Issue [#1438](https://github.com/horizon-rust/horizon/issues/1438); possibly related: [#526](https://github.com/horizon-rust/horizon/issues/526). The templates' block entities now keep their patterns ([#1928](https://github.com/horizon-rust/horizon/issues/1928)).
-
-</details>
-
-#### Enchanted loot in End cities
-
-Armour and tools in End city chests should come enchanted, as in vanilla.
-
-<details><summary>Technical</summary>
-
-`loot.rs` implements `enchant_with_levels`: find why the End city chest table's rolls come out bare, and compare them with vanilla's for a few seeds. Issues [#1437](https://github.com/horizon-rust/horizon/issues/1437), [#1660](https://github.com/horizon-rust/horizon/issues/1660). The loot's enchantment functions now reach every table that rolls ([#1911](https://github.com/horizon-rust/horizon/issues/1911), [#2037](https://github.com/horizon-rust/horizon/issues/2037)).
-
-</details>
-
 ## Recently shipped

+- **Enchanted loot in End cities** (v0.2.73): Armour and tools in End city chests should come enchanted, as in vanilla. [#1437](https://github.com/horizon-rust/horizon/issues/1437) · [#1660](https://github.com/horizon-rust/horizon/issues/1660) · [#1911](https://github.com/horizon-rust/horizon/issues/1911) · [#2037](https://github.com/horizon-rust/horizon/issues/2037)
+- **End city banners keep their pattern** (v0.2.67): Banners in End cities show as plain magenta instead of with their pattern. [#1438](https://github.com/horizon-rust/horizon/issues/1438) · [#526](https://github.com/horizon-rust/horizon/issues/526) · [#1928](https://github.com/horizon-rust/horizon/issues/1928)
+- **Play in your language** (v0.2.65): Item names, container titles and server messages follow the language you pick, as in vanilla. Today parts of the game stay in English. [#1806](https://github.com/horizon-rust/horizon/issues/1806) · [#1594](https://github.com/horizon-rust/horizon/issues/1594) · [#1672](https://github.com/horizon-rust/horizon/issues/1672)
 - **Chickens flap while they fall** (v0.2.67): Chickens should flap their wings while they fall, not stand still in the air. [#1706](https://github.com/horizon-rust/horizon/issues/1706) · [#1892](https://github.com/horizon-rust/horizon/issues/1892)
 - **Ctrl+Backspace and scroll bars in menus** (v0.2.67): Ctrl+Backspace should delete a whole word in the creative search, and every list's scroll bar should be draggable. [#1764](https://github.com/horizon-rust/horizon/issues/1764) · [#1782](https://github.com/horizon-rust/horizon/issues/1782) · [#1884](https://github.com/horizon-rust/horizon/issues/1884) · [#1931](https://github.com/horizon-rust/horizon/issues/1931)
 - **A pointing hand over buttons** (v0.2.67): The mouse pointer should turn into a pointing hand over menu buttons, as in vanilla 26.3. [#1347](https://github.com/horizon-rust/horizon/issues/1347) · [#1897](https://github.com/horizon-rust/horizon/issues/1897)
@@ -170,3 +170,45 @@ BlueMap is licensed under the MIT license:
 > 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.
+
+## JOML
+
+`crates/horizon-client-render/src/camera.rs` (`joml::Mat4::rotation`, `invert_orthonormal`) and
+`crates/horizon-client-render/src/gfx/pack_uniforms.rs` (`invert_generic`, `invert_affine`, the
+formulas of `pack_projection` and `shadow_ortho`) adapt the float arithmetic of
+`Matrix4f.rotation(Quaternionfc)`, `invertOrthonormal`, `invertGenericNonThis`, `invertAffine`,
+`setPerspective` and `setOrtho` from
+[JOML](https://github.com/JOML-CI/JOML/tree/faf9eef2511242122beb6055fe3da92daed214c5) 1.10.9, the
+library vanilla 26.3 uses, so that shader packs get the same matrices to the last bit. Changes:
+ported to Rust; the pack_uniforms.rs functions drop JOML's property flags, and
+`pack_projection` works the formula in doubles. The copyright line and license notice also head
+both files.
+
+`camera.rs` also adapts `Quaternionf.rotationX`, `rotationY` and `rotationZ`,
+`Matrix4f.rotateAffine` and `Vector4f.mulAffine` (`joml::Quat::rotation_x`/`_y`/`_z`,
+`joml::Mat4::rotate_affine`, `transform_affine`), for the sky's positions shader packs read.
+Changes: ported to Rust; `rotate_affine` keeps only the affine case.
+
+```
+The MIT License
+
+Copyright (c) 2015-2026 Richard Greenlees
+
+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.
+```
@@ -0,0 +1,42 @@
+# Entity occlusion split measurements — 2026-11-02
+
+These measurements came from the pre-split integration branch for PR #7054. That build contained the entity-occlusion rewrite and particle light lookup cache; Particle Culling was Off. They are useful comparison evidence, but they are not a benchmark of this isolated entity-only commit. The cache-only run in PR #7391 measured effectively the same CPU time on the ordinary scene, but the combined result still cannot isolate interactions.
+
+Host: Intel Core i7-3770S, Intel HD Graphics 4000, Vulkan/Mesa, 675×727, render distance 4, VSync off, 260 FPS cap. Two opposite-order passes measured for 8 seconds after warmup. Values are means. CPU is harness average CPU ms per frame; p99 is frame time. The driver supplied no usable GPU timing.
+
+## Ordinary scene
+
+The scene had 24 mobs, roughly 9,400–10,100 rain particles and campfire smoke.
+
+| Build and mode | FPS | CPU ms/frame | Frame p99 ms |
+| --- | ---: | ---: | ---: |
+| Main, entity culling Off | 88.59 | 1.829 | 24.51 |
+| Pre-split integration branch, all culling Off | 88.33 | 2.063 | 24.51 |
+| Main, entity culling Synchronous | 89.34 | 1.965 | 23.99 |
+| Pre-split integration branch, entity Synchronous | 89.13 | 2.113 | 24.15 |
+
+This normal-scene run does not show a large FPS change; its CPU differences are small relative to frame time and not attributable to the entity-only change by themselves.
+
+## Opaque-wall scene
+
+A 32×32 platform at Y=300, a 7-block wall with a one-block vertical opening, and 192 pigs spawned behind the wall (216 mobs in the captured scene). The player looked toward the opening from the near side. The same world and camera path were used for the main and integration builds.
+
+| Build and mode | FPS | CPU ms/frame | Frame p99 ms |
+| --- | ---: | ---: | ---: |
+| Main, Off | 89.08 | 2.423 | 13.52 |
+| Integration branch, Off | 89.23 | 2.355 | 13.27 |
+| Main, Synchronous | 92.81 | 2.566 | 14.60 |
+| Integration branch, Synchronous | 93.21 | 2.550 | 12.84 |
+| Main, Asynchronous | 92.73 | 2.364 | 13.04 |
+| Integration branch, Asynchronous | 92.62 | 2.314 | 13.18 |
+
+The asynchronous mode reduced measured CPU time slightly in this wall scene but did not improve FPS beyond run-to-run spread. This is a synthetic occlusion-heavy scene, not a broad performance claim.
+
+## Captures
+
+The HUD performance overlay is visible in each capture. The integration-build screenshots were recorded with the same wall and camera position in Off, Synchronous, and Asynchronous modes.
+
+- Main, Off: `main-off.png`
+- Integration branch, Off: `branch-off.png`
+- Integration branch, Synchronous: `branch-sync.png`
+- Integration branch, Asynchronous: `branch-async.png`
@@ -0,0 +1,42 @@
+# Entity occlusion pipeline — release/OpenGL run (2026-11-04)
+
+This is the final local smoke benchmark for the entity-occlusion pipeline before opening the PR. It was run from the branch after the release build completed, with the OpenGL backend selected explicitly. The same process created each scene, switched the culling mode, flew the camera for two seconds, collected frame/CPU telemetry, and captured the screenshot after the scene settled.
+
+**Host:** Intel Core i7-3770S, Intel HD Graphics 4000, Mesa OpenGL 4.2
+**Window:** 1280×720, offscreen, VSync disabled
+**World:** fresh temporary home, 32×32 platform at Y=300; wall scenes add a solid stone wall and an optional one-block slit
+**Entities:** 24 pigs in the normal scene, 192 pigs in wall scenes, 512 pigs in stress scenes
+**Settings:** render distance 8, `entityCullingPrecheck:64`, FPS overlay on, no resource-pack occlusion assumptions
+**Build:** `cargo build --release -p horizon-client`
+
+## Results
+
+The values below are branch-only measurements. They are useful for comparing the three modes under identical geometry and for checking that the worker is doing useful work. A fresh main binary was not built in this short pass, so these numbers do not claim a controlled main-to-branch delta.
+
+| Scene | Off FPS / CPU p50 | Sync FPS / CPU p50 | Async FPS / CPU p50 | Async entities culled |
+| --- | ---: | ---: | ---: | ---: |
+| `entity_normal` (24 visible) | 240.5 / 0.586 ms | 233.5 / 0.762 ms | 239.3 / 0.686 ms | 0 |
+| `entity_wall` (192, solid) | 228.8 / 1.245 ms | 318.6 / 1.342 ms | **324.5 / 0.478 ms** | 124,608 |
+| `entity_wall_slit` (192, one-block slit) | 231.4 / 1.102 ms | 265.0 / 1.387 ms | **281.2 / 0.716 ms** | 102,826 |
+| `entity_stress` (512, solid) | 190.3 / 2.467 ms | 299.2 / 2.593 ms | **325.5 / 0.691 ms** | 290,234 |
+| `entity_stress_slit` (512, one-block slit) | 190.4 / 2.476 ms | 262.2 / 2.573 ms | **262.1 / 1.297 ms** | 227,301 |
+
+Async telemetry confirmed that the render thread stayed non-blocking (`try_recv`/`try_send`, `worker_blocking_wait_ms: 0`). The latest wall/slit run completed 562 worker jobs, queued 3,982 queries, avoided about 4.0 million entity bytes, and had 379 ns recent p50 worker-job time. The solid 512-pig run culled 15,552 generated vertices; the slit run culled 120,290 generated vertices. The normal scene recorded no pre-model hides and kept the opt-in path close to Off.
+
+## Captures
+
+Every image includes the FPS performance overlay. The names are `<mode>-<scene>.png`:
+
+- [Off — normal](screenshots/off-entity_normal.png), [wall](screenshots/off-entity_wall.png), [wall slit](screenshots/off-entity_wall_slit.png), [stress](screenshots/off-entity_stress.png), [stress slit](screenshots/off-entity_stress_slit.png)
+- [Sync — normal](screenshots/sync-entity_normal.png), [wall](screenshots/sync-entity_wall.png), [wall slit](screenshots/sync-entity_wall_slit.png), [stress](screenshots/sync-entity_stress.png), [stress slit](screenshots/sync-entity_stress_slit.png)
+- [Async — normal](screenshots/async-entity_normal.png), [wall](screenshots/async-entity_wall.png), [wall slit](screenshots/async-entity_wall_slit.png), [stress](screenshots/async-entity_stress.png), [stress slit](screenshots/async-entity_stress_slit.png)
+
+## Reproduction
+
+From the repository root, with prepared 26.3 resources available:
+
+```sh
+python3 tools/entity_occlusion_bench.py
+```
+
+The script uses fresh temporary game data, the release binary in `target/release`, OpenGL, the FPS overlay, and writes JSON plus captures under `/tmp/horizon-entity-occlusion-release-quick/`.
@@ -0,0 +1,5 @@
+# `keys.contains(&KeyCode::ShiftLeft)` reads a mapping by its default key: ask by `Action`, so the
+# mapping is named and every device that can hold it counts.
+disallowed-methods = [
+    { path = "horizon_client_input::held::HeldKeys::contains", reason = "use `held(Action::..)`, or `raw` for a key that is no mapping's default", allow-invalid = true },
+]
@@ -93,7 +93,7 @@ pub fn kind_of(path: &Path) -> Option<Kind> {
        "hmod" => Some(Kind::Mod),
        "hnmod" => Some(Kind::NativeMod),
        "hpack" => Some(Kind::Modpack),
-        "zip" => Some(Kind::ResourcePack),
+        "zip" => Some(horizon_mods::index::zip_kind(path)),
        "hshader" => Some(Kind::Shader),
        _ => None,
    }
@@ -108,6 +108,16 @@ impl<T> CompiledChoices<T> {
            multipart: self.multipart.iter().map(|c| c.map(&mut f)).collect(),
        }
    }
+    /// A variant that needs no random selection and produces exactly one model.
+    pub fn single_variant(&self, selected: &SelectedModels) -> Option<&T> {
+        let SelectedModels::Variant(index) = selected else {
+            return None;
+        };
+        match self.variants.get(*index)? {
+            Choice::Single(value) => Some(value),
+            Choice::Weighted { .. } => None,
+        }
+    }
    /// The variant `particleMaterial` comes from: the first entry of a weighted
    /// list (`WeightedVariants`) and, for a multipart root, of its first
    /// selector whether or not that selector applies (`MultiPartModel`).
@@ -0,0 +1,22 @@
+//! NBT path parser output and byte cursor for the pinned Java oracle.
+use horizon_client_core::nbt_path::NbtPath;
+use std::io::{BufRead, Write};
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut args = std::env::args().skip(1);
+    let input = std::io::BufReader::new(std::fs::File::open(args.next().unwrap())?);
+    let mut output = std::io::BufWriter::new(std::fs::File::create(args.next().unwrap())?);
+    for line in input.lines() {
+        let text: String = serde_json::from_str(&line?)?;
+        match NbtPath::parse_prefix(&text) {
+            Ok((path, cursor)) => {
+                write!(output, "OK {cursor} ")?;
+                for value in path.as_str().as_bytes() {
+                    write!(output, "{value:02x}")?;
+                }
+                writeln!(output)?;
+            }
+            Err(error) => writeln!(output, "ERR {} {}", error.cursor, error.key)?,
+        }
+    }
+    Ok(())
+}
@@ -143,7 +143,9 @@ impl<'a> Fields<'a> {
    /// `RandomizableContainer.tryLoadLootTable` / `trySaveLootTable`; true when the
    /// block entity has a loot table (and so saves no items).
    fn loot_table(&mut self) -> bool {
-        let Some(table) = text(self.input.get("LootTable")) else {
+        let Some(table) =
+            text(self.input.get("LootTable")).and_then(|id| crate::identifier::normalize_id(&id))
+        else {
            return false;
        };
        self.put("LootTable", string(&table));
@@ -905,6 +907,16 @@ mod tests {
        assert_eq!(out.get("LootTable"), Some(&string("minecraft:chests/x")));
    }

+    #[test]
+    fn invalid_loot_table_leaves_items_intact() {
+        let out = canon(
+            "{id:\"minecraft:barrel\",x:1,y:2,z:3,LootTable:\"INVALID TABLE\",\
+             Items:[{Slot:0b,id:\"minecraft:stone\",count:1}]}",
+        );
+        assert!(out.get("Items").is_some());
+        assert!(out.get("LootTable").is_none());
+    }
+
    #[test]
    fn items_are_validated_and_sorted_by_slot() {
        let out = canon(
@@ -111,7 +111,15 @@ impl Parser<'_> {
            map.insert(key, self.value()?);
            self.ws();
            match self.peek() {
-                Some(b',') => self.i += 1,
+                // SnbtGrammar: an entry may be followed by a comma before the brace.
+                Some(b',') => {
+                    self.i += 1;
+                    self.ws();
+                    if self.peek() == Some(b'}') {
+                        self.i += 1;
+                        return Ok(Value::Object(map));
+                    }
+                }
                Some(b'}') => {
                    self.i += 1;
                    return Ok(Value::Object(map));
@@ -140,7 +148,15 @@ impl Parser<'_> {
            list.push(self.value()?);
            self.ws();
            match self.peek() {
-                Some(b',') => self.i += 1,
+                // SnbtGrammar: a list or array may end with a comma.
+                Some(b',') => {
+                    self.i += 1;
+                    self.ws();
+                    if self.peek() == Some(b']') {
+                        self.i += 1;
+                        return Ok(Value::Array(list));
+                    }
+                }
                Some(b']') => {
                    self.i += 1;
                    return Ok(Value::Array(list));
@@ -207,9 +223,11 @@ fn style_flag(v: Option<&Value>) -> Option<bool> {
    }
 }

-fn untrusted_http_url(url: &str) -> bool {
-    // ExtraCodecs.UNTRUSTED_URI / Util.parseAndValidateUntrustedUri: http and
-    // https only, scheme case-insensitive.
+/// ExtraCodecs.UNTRUSTED_URI / Util.parseAndValidateUntrustedUri: http and
+/// https only, scheme case-insensitive. Every `open_url` a server sends must
+/// pass it: anything else (`file:`, a UNC path, a custom protocol handler)
+/// could start a program through the system's URL handler.
+pub fn untrusted_http_url(url: &str) -> bool {
    url.split_once(':').is_some_and(|(scheme, _)| {
        scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https")
    })
@@ -495,6 +513,22 @@ pub fn name_text(tag: &Tag) -> Text {
 #[cfg(test)]
 mod tests {
    use super::*;
+    /// SnbtGrammar: a compound or list may end with one comma; two in a row
+    /// stay an error.
+    #[test]
+    fn a_component_takes_one_trailing_comma() {
+        let parse = |s: &str| parse_snbt(s).map(|(v, _)| v);
+        assert_eq!(
+            parse("{text:\"a\",color:\"red\",}"),
+            parse("{text:\"a\",color:\"red\"}")
+        );
+        assert_eq!(
+            parse("[\"a\", {text:\"b\",} ,]"),
+            parse("[\"a\",{text:\"b\"}]")
+        );
+        assert!(parse("{text:\"a\",,}").is_err());
+        assert!(parse("[\"a\",,]").is_err());
+    }

    #[test]
    fn hex_color_follows_text_color_parse_color() {
@@ -388,6 +388,36 @@ pub fn apply_deprecated(map: &mut HashMap<String, String>, json: &[u8]) {
    }
 }

+/// `Language.loadFromJson` for one `lang/<code>.json`: its entries go into `map` in file order.
+/// A file that is plain JSON reads as before; any other goes through Gson's lenient reader
+/// (`#`, `//` and `/* */` comments, unquoted or single-quoted names and values, raw control
+/// characters in strings, `=` or `=>` and `;`), which vanilla reads lang files with (expected
+/// from `Language.loadFromJson`, Gson). A file that is not JSON even so adds nothing; a value
+/// that is not a string, number or boolean (`GsonHelper.convertToString`) ends the file there.
+pub fn read_lang_file(bytes: &[u8], map: &mut HashMap<String, String>) {
+    use horizon_world::datafix::json::{Json, parse_lenient};
+    if let Ok(entries) = serde_json::from_slice::<HashMap<String, String>>(bytes) {
+        map.extend(entries);
+        return;
+    }
+    let text = String::from_utf8_lossy(bytes);
+    // Gson's JsonReader skips a leading byte order mark.
+    let text = text.strip_prefix('\u{feff}').unwrap_or(&text);
+    let utf16: Vec<u16> = text.encode_utf16().collect();
+    let Some(Json::Obj(entries)) = parse_lenient(&utf16) else {
+        return;
+    };
+    for (key, value) in entries {
+        let value = match value {
+            Json::Str(s) => String::from_utf16_lossy(&s),
+            Json::Num(n) => n,
+            Json::Bool(b) => b.to_string(),
+            Json::Null | Json::Arr(_) | Json::Obj(_) => break,
+        };
+        map.insert(String::from_utf16_lossy(&key), value);
+    }
+}
+
 impl Language {
    /// ClientLanguage.loadFrom: en_us first, then the selected language, each
    /// from every namespace and every source in priority order (later sources
@@ -413,9 +443,7 @@ impl Language {
                    else {
                        continue;
                    };
-                    if let Ok(entries) = serde_json::from_slice::<HashMap<String, String>>(&bytes) {
-                        map.extend(entries);
-                    }
+                    read_lang_file(&bytes, &mut map);
                }
            }
        }
@@ -875,4 +903,165 @@ mod tests {
            ["en_us", "fr_fr"]
        );
    }
+
+    fn read(body: &str) -> HashMap<String, String> {
+        let mut map = HashMap::new();
+        read_lang_file(body.as_bytes(), &mut map);
+        map
+    }
+    fn entries(pairs: &[(&str, &str)]) -> HashMap<String, String> {
+        pairs
+            .iter()
+            .map(|(k, v)| ((*k).to_owned(), (*v).to_owned()))
+            .collect()
+    }
+
+    #[test]
+    fn a_plain_json_lang_file_reads_as_before() {
+        let body = "{\"a\": \"Apple \\\"quoted\\\" \\u00e9\", \"b\": \"\", \"a\": \"Again\"}";
+        let strict: HashMap<String, String> = serde_json::from_str(body).unwrap();
+        assert_eq!(read(body), strict);
+        assert_eq!(read(body), entries(&[("a", "Again"), ("b", "")]));
+    }
+
+    #[test]
+    fn lang_files_read_with_comments() {
+        let want = entries(&[("a", "Apple"), ("b", "Banana # not a comment // either")]);
+        for body in [
+            "# header\n{\n# a comment\n\"a\": \"Apple\",\n\"b\": \"Banana # not a comment // either\"\n}\n",
+            "// header\n{\"a\": \"Apple\", // after\n\"b\": \"Banana # not a comment // either\"}",
+            "/* header\n over lines */{\"a\": /* inline */ \"Apple\", \"b\": \"Banana # not a comment // either\"}",
+        ] {
+            assert_eq!(read(body), want, "{body}");
+        }
+    }
+
+    #[test]
+    fn lang_files_read_unquoted_and_single_quoted_names_and_values() {
+        assert_eq!(
+            read("{a: 'Apple', 'b': \"Banana\", c: Cherry}"),
+            entries(&[("a", "Apple"), ("b", "Banana"), ("c", "Cherry")])
+        );
+        // A single-quoted string may hold a double quote, and the reverse.
+        assert_eq!(
+            read("{'a': 'say \"hi\"', \"b\": \"it's\"}"),
+            entries(&[("a", "say \"hi\""), ("b", "it's")])
+        );
+    }
+
+    #[test]
+    fn lang_files_read_raw_control_characters_in_strings() {
+        assert_eq!(
+            read("{\"a\": \"tab\there\", \"b\": \"two\nlines\"}"),
+            entries(&[("a", "tab\there"), ("b", "two\nlines")])
+        );
+    }
+
+    #[test]
+    fn lang_files_read_gson_separators_and_a_byte_order_mark() {
+        assert_eq!(
+            read("\u{feff}{\"a\" = \"Apple\"; \"b\" => \"Banana\"}"),
+            entries(&[("a", "Apple"), ("b", "Banana")])
+        );
+        // A trailing comma before `}` is not JSON even to Gson's lenient reader.
+        assert_eq!(read("{# c\n\"a\": \"Apple\",}"), HashMap::new());
+    }
+
+    #[test]
+    fn numbers_and_booleans_read_as_their_text() {
+        // GsonHelper.convertToString: a primitive reads as its text.
+        assert_eq!(
+            read("{\"a\": 1.50, \"b\": true, \"c\": -2e3}"),
+            entries(&[("a", "1.50"), ("b", "true"), ("c", "-2e3")])
+        );
+    }
+
+    #[test]
+    fn a_value_that_is_no_text_ends_the_file_there() {
+        assert_eq!(
+            read("# c\n{\"a\": \"Apple\", \"b\": [\"x\"], \"c\": \"Cherry\"}"),
+            entries(&[("a", "Apple")])
+        );
+        assert_eq!(read("{\"a\": null, \"b\": \"Banana\"}"), HashMap::new());
+    }
+
+    #[test]
+    fn a_lang_file_that_is_not_json_adds_nothing() {
+        for body in [
+            "# c\n{\"a\": \"Apple\"",
+            "[\"a\"]",
+            "\"a\"",
+            "",
+            "{\"a\": \"Apple\"} {",
+        ] {
+            assert_eq!(read(body), HashMap::new(), "{body:?}");
+        }
+    }
+
+    #[test]
+    fn a_pack_lang_file_with_comments_layers_over_english() {
+        let base = Mem(HashMap::from([(
+            "assets/minecraft/lang/en_us.json".into(),
+            br#"{"a":"Apple","b":"Banana"}"#.to_vec(),
+        )]));
+        let pack = Mem(HashMap::from([(
+            "assets/minecraft/lang/fr_fr.json".into(),
+            b"{\n# Fruits\n\"a\": \"Pomme\"\n}\n".to_vec(),
+        )]));
+        let sources: [&dyn ResourceSource; 2] = [&base, &pack];
+        let fr = Language::load(&sources, "fr_fr");
+        assert_eq!(fr.get("a"), Some("Pomme"));
+        assert_eq!(fr.get("b"), Some("Banana"));
+    }
+
+    /// Every lang file of a downloaded pack, e.g. BACAP Language Pack:
+    /// `HORIZON_LANG_PACK_DIR=<pack>/assets/minecraft/lang cargo test -p horizon-client-core
+    /// lang::tests::every_lang_file_of_a_pack_reads -- --ignored --nocapture`.
+    #[test]
+    #[ignore = "needs a downloaded pack in HORIZON_LANG_PACK_DIR"]
+    fn every_lang_file_of_a_pack_reads() {
+        let Ok(dir) = std::env::var("HORIZON_LANG_PACK_DIR") else {
+            return;
+        };
+        let mut failed = Vec::new();
+        let mut paths: Vec<_> = std::fs::read_dir(dir)
+            .unwrap()
+            .map(|e| e.unwrap().path())
+            .collect();
+        paths.sort();
+        for path in paths {
+            let bytes = std::fs::read(&path).unwrap();
+            let strict = serde_json::from_slice::<HashMap<String, String>>(&bytes).is_ok();
+            let mut map = HashMap::new();
+            read_lang_file(&bytes, &mut map);
+            // An independent count: the distinct `"name":` that start a line.
+            let text = String::from_utf8_lossy(&bytes);
+            let names: std::collections::HashSet<&str> = text
+                .lines()
+                .filter_map(|line| {
+                    let rest = line.trim_start().strip_prefix('"')?;
+                    let mut escaped = false;
+                    let end = rest.char_indices().find_map(|(i, c)| {
+                        let close = c == '"' && !escaped;
+                        escaped = c == '\\' && !escaped;
+                        close.then_some(i)
+                    })?;
+                    rest[end + 1..]
+                        .trim_start()
+                        .starts_with(':')
+                        .then(|| &rest[..end])
+                })
+                .collect();
+            println!(
+                "{}: strict {strict}, {} keys, {} names",
+                path.display(),
+                map.len(),
+                names.len()
+            );
+            if map.is_empty() || map.len() != names.len() {
+                failed.push(path);
+            }
+        }
+        assert!(failed.is_empty(), "{failed:?}");
+    }
 }
@@ -81,7 +81,7 @@ fn elements(tag: &Tag) -> Option<Vec<Tag>> {
 }
 /// `DoubleTag.intValue` / `FloatTag.intValue` floor before the i32 conversion;
 /// integral tags use their intValue narrowing. Byte arrays then keep the low byte.
-fn int_value(t: &Tag) -> Option<i32> {
+pub fn int_value(t: &Tag) -> Option<i32> {
    Some(match t {
        Tag::Byte(v) => i32::from(*v),
        Tag::Short(v) => i32::from(*v),
@@ -194,6 +194,20 @@ impl NbtPath {
    pub fn is_empty(&self) -> bool {
        self.nodes.is_empty()
    }
+    /// Whether this selects a compound-field chain, including filtered or quoted fields.
+    /// Matching a root or child does not change that subtree's writer provenance.
+    pub fn is_field_path(&self, fields: &[&str]) -> bool {
+        let mut fields = fields.iter();
+        for node in &self.nodes {
+            match node {
+                Node::MatchRoot(_) => {}
+                Node::Child(name) | Node::MatchChild(name, _)
+                    if fields.next().copied() == Some(name.as_str()) => {}
+                _ => return false,
+            }
+        }
+        fields.next().is_none()
+    }
    fn not_found(&self, node: usize) -> PathError {
        let end = self.ends[node];
        PathError::new(
@@ -712,11 +726,16 @@ fn parse_node(text: &str, i: usize, first: bool) -> Result<(Node, usize), PathEr
                Some(b']') => Ok((Node::AllElements, j + 1)),
                _ => {
                    let start = j;
-                    if b.get(j) == Some(&b'-') {
+                    // StringReader.readInt scans all allowed number characters
+                    // before parsing, including malformed signs and decimal points.
+                    while b
+                        .get(j)
+                        .is_some_and(|c| c.is_ascii_digit() || matches!(c, b'-' | b'.'))
+                    {
                        j += 1;
                    }
-                    while b.get(j).is_some_and(u8::is_ascii_digit) {
-                        j += 1;
+                    if start == j {
+                        return Err(PathError::new("parsing.int.expected", vec![], start));
                    }
                    let n: i32 = text[start..j].parse().map_err(|_| {
                        PathError::new(
@@ -778,6 +797,13 @@ fn read_quoted(text: &str, i: usize) -> Result<(String, usize), PathError> {
    let mut escaped = false;
    for (o, c) in text[i + 1..].char_indices() {
        if escaped {
+            if c != quote && c != '\\' {
+                return Err(PathError::new(
+                    "parsing.quote.escape",
+                    vec![c.to_string()],
+                    i + 1 + o,
+                ));
+            }
            out.push(c);
            escaped = false;
        } else if c == '\\' {
@@ -826,6 +852,59 @@ fn parse_compound(text: &str, i: usize) -> Result<(Tag, usize), PathError> {
 #[cfg(test)]
 mod tests {
    use super::*;
+    #[test]
+    fn quoted_escapes_and_index_tokens_match_brigadier() {
+        let cases = [
+            (r#""a\q""#, "parsing.quote.escape", vec!["q"], 3),
+            (r#"'a\x'"#, "parsing.quote.escape", vec!["x"], 3),
+            ("[1.0]", "parsing.int.invalid", vec!["1.0"], 1),
+            ("[.]", "parsing.int.invalid", vec!["."], 1),
+            ("[--1]", "parsing.int.invalid", vec!["--1"], 1),
+            ("[2147483648]", "parsing.int.invalid", vec!["2147483648"], 1),
+            ("[+1]", "parsing.int.expected", vec![], 1),
+            (r#""é\q""#, "parsing.quote.escape", vec!["q"], 4),
+            (r#""é"[1.0]"#, "parsing.int.invalid", vec!["1.0"], 5),
+        ];
+        let mut failures = Vec::new();
+        for (text, key, args, cursor) in cases {
+            match NbtPath::parse_prefix(text) {
+                Err(error) if error.key == key && error.args == args && error.cursor == cursor => {}
+                other => failures.push(format!("{text:?}: {other:?}")),
+            }
+        }
+        assert!(failures.is_empty(), "{}", failures.join("\n"));
+    }
+
+    #[test]
+    fn valid_quoted_escapes_still_select_the_exact_field() {
+        let root = Tag::compound([("a\"b", Tag::Int(7)), ("a\\b", Tag::Int(8))]);
+        for (path, value) in [(r#""a\"b""#, 7), (r#""a\\b""#, 8)] {
+            assert_eq!(
+                NbtPath::parse(path).unwrap().get(&root).unwrap(),
+                vec![Tag::Int(value)]
+            );
+        }
+    }
+
+    #[test]
+    fn field_provenance_handles_quotes_and_filters_without_matching_lists() {
+        for text in [
+            "blockState.properties",
+            "\"blockState\".\"properties\"",
+            "{source:1b}.blockState.properties",
+            "blockState{id:\"minecraft:piston_head\"}.properties",
+        ] {
+            let path = NbtPath::parse(text).unwrap();
+            assert!(path.is_field_path(&["blockState", "properties"]));
+            assert!(!path.is_field_path(&["blockState"]));
+        }
+        assert!(NbtPath::parse("{source:1b}").unwrap().is_field_path(&[]));
+        assert!(
+            !NbtPath::parse("blockState[].properties")
+                .unwrap()
+                .is_field_path(&["blockState", "properties"])
+        );
+    }

    fn tag(s: &str) -> Tag {
        parse_snbt(s).unwrap().0
@@ -964,6 +964,10 @@ impl Scoreboard {
    pub fn tracked(&self) -> Vec<String> {
        self.holder_order.stream().map(str::to_owned).collect()
    }
+    /// Every holder on a team (`teamsByPlayer.keySet()`).
+    pub fn team_members(&self) -> impl Iterator<Item = &str> {
+        self.team_of.keys().map(String::as_str)
+    }

    // teams
    pub fn team(&self, name: &str) -> Option<&Team> {
@@ -8,11 +8,20 @@ pub use horizon_world::snbt_text::{java_double, java_float, quote_and_escape, to

 // ---- the coloured form -----------------------------------------------------

+/// Writer provenance for a live moving-piston command read, or its selected subtree.
+#[derive(Clone, Copy)]
+pub enum PistonPart {
+    Entity,
+    State,
+    Properties,
+}
+
 struct Pretty {
    indentation: String,
    result: Text,
    indent_depth: usize,
    depth: usize,
+    piston: Option<PistonPart>,
 }
 fn is_numeric(t: &Tag) -> bool {
    matches!(
@@ -58,6 +67,10 @@ impl Pretty {
        self.lit("]", None);
    }
    fn sub(&mut self, tag: &Tag, indent: bool) {
+        self.sub_with(tag, indent, None);
+    }
+    fn sub_with(&mut self, tag: &Tag, indent: bool, piston: Option<PistonPart>) {
+        let previous = std::mem::replace(&mut self.piston, piston);
        if indent {
            self.indent_depth += 1;
        }
@@ -67,6 +80,7 @@ impl Pretty {
            self.indent_depth -= 1;
        }
        self.depth -= 1;
+        self.piston = previous;
    }
    fn visit(&mut self, tag: &Tag) {
        match tag {
@@ -157,7 +171,11 @@ impl Pretty {
                "\n"
            };
            let n = c.len();
-            for (i, (k, v)) in java_hash_order(c).into_iter().enumerate() {
+            let entries = match self.piston {
+                Some(part) => piston_hash_order(c, part),
+                None => java_hash_order(c),
+            };
+            for (i, (k, v)) in entries.into_iter().enumerate() {
                self.lit(&entry, None);
                let key = string_of(k);
                if !key.is_empty()
@@ -171,7 +189,12 @@ impl Pretty {
                }
                self.lit(":", None);
                self.lit(" ", None);
-                self.sub(v, true);
+                let child = match (self.piston, key.as_str()) {
+                    (Some(PistonPart::Entity), "blockState") => Some(PistonPart::State),
+                    (Some(PistonPart::State), "properties") => Some(PistonPart::Properties),
+                    _ => None,
+                };
+                self.sub_with(v, true, child);
                if i + 1 < n {
                    self.lit(",", None);
                    self.lit(spacing, None);
@@ -186,22 +209,61 @@ impl Pretty {
        }
    }
 }
+fn hash_bucket(len: usize, key: &horizon_world::nbt::JavaString) -> usize {
+    let mut capacity = 16usize;
+    while len > capacity * 3 / 4 {
+        capacity *= 2;
+    }
+    let h = string_of(key)
+        .encode_utf16()
+        .fold(0u32, |h, ch| h.wrapping_mul(31).wrapping_add(u32::from(ch)));
+    ((h ^ (h >> 16)) as usize) & (capacity - 1)
+}
+fn piston_hash_order(
+    c: &horizon_world::nbt::Compound,
+    part: PistonPart,
+) -> Vec<(&horizon_world::nbt::JavaString, &Tag)> {
+    let mut entries: Vec<_> = c.iter().collect();
+    match part {
+        PistonPart::Entity => {
+            // saveAdditional, then the base's components and saveMetadata.
+            let fields = [
+                "blockState",
+                "facing",
+                "progress",
+                "extending",
+                "source",
+                "components",
+                "id",
+                "x",
+                "y",
+                "z",
+            ];
+            entries.sort_by_key(|(k, _)| {
+                (
+                    hash_bucket(c.len(), k),
+                    fields
+                        .iter()
+                        .position(|s| *s == string_of(k))
+                        .unwrap_or(fields.len()),
+                )
+            });
+        }
+        PistonPart::Properties => {
+            // StateDefinition builds property codecs in sorted-name order.
+            // DFU's nested map-pair encoder writes the second codec first.
+            entries.sort_by_key(|(k, _)| (hash_bucket(c.len(), k), std::cmp::Reverse(*k)));
+        }
+        PistonPart::State => return java_hash_order(c),
+    }
+    entries
+}
 /// The iteration order of the `HashMap<String, Tag>` a `CompoundTag` holds,
 /// for a map that grew to its size by insertion: buckets by
 /// `HashMap.hash(String.hashCode())`, keys sharing a bucket in key order.
 pub fn java_hash_order(
    c: &horizon_world::nbt::Compound,
 ) -> Vec<(&horizon_world::nbt::JavaString, &Tag)> {
-    let mut capacity = 16usize;
-    while c.len() > capacity * 3 / 4 {
-        capacity *= 2;
-    }
-    let bucket = |k: &horizon_world::nbt::JavaString| {
-        let h = string_of(k)
-            .encode_utf16()
-            .fold(0u32, |h, ch| h.wrapping_mul(31).wrapping_add(u32::from(ch)));
-        ((h ^ (h >> 16)) as usize) & (capacity - 1)
-    };
    // Keys sharing a bucket iterate in insertion order: the order vanilla's
    // savers write them, as far as it is known here.
    const WRITE_ORDER: &[&str] = &[
@@ -268,7 +330,7 @@ pub fn java_hash_order(
            .unwrap_or(WRITE_ORDER.len())
    };
    let mut entries: Vec<_> = c.iter().collect();
-    entries.sort_by_key(|(k, _)| (bucket(k), rank(k)));
+    entries.sort_by_key(|(k, _)| (hash_bucket(c.len(), k), rank(k)));
    entries
 }
 /// `NbtUtils.toPrettyComponent`: the coloured, unindented form.
@@ -281,6 +343,19 @@ pub fn pretty_indented(tag: &Tag, indentation: &str) -> Text {
        result: Text::empty(),
        indent_depth: 0,
        depth: 0,
+        piston: None,
+    };
+    p.visit(tag);
+    p.result
+}
+/// Command-only writer order; ordinary pretty printing keeps its existing policy.
+pub fn pretty_piston(tag: &Tag, part: PistonPart) -> Text {
+    let mut p = Pretty {
+        indentation: String::new(),
+        result: Text::empty(),
+        indent_depth: 0,
+        depth: 0,
+        piston: Some(part),
    };
    p.visit(tag);
    p.result
@@ -295,6 +370,33 @@ mod tests {
        to_snbt(&parse_snbt(s).unwrap().0)
    }
    #[test]
+    fn live_piston_writer_order_does_not_change_default_pretty() {
+        let tag = parse_snbt(
+            r#"{id:"minecraft:piston",blockState:{id:"minecraft:piston_head",properties:{facing:"east",short:"false",type:"normal"}},components:{},x:1,y:100,z:0,facing:5b,progress:0.0f,source:1b,extending:1b}"#,
+        ).unwrap().0;
+        let ordinary = r#"{blockState: {id: "minecraft:piston_head", properties: {facing: "east", short: "false", type: "normal"}}, components: {}, x: 1, facing: 5b, progress: 0.0f, y: 100, z: 0, id: "minecraft:piston", source: 1b, extending: 1b}"#;
+        assert_eq!(pretty(&tag).plain(), ordinary);
+        assert_eq!(
+            pretty_piston(&tag, PistonPart::Entity).plain(),
+            r#"{blockState: {id: "minecraft:piston_head", properties: {short: "false", facing: "east", type: "normal"}}, components: {}, x: 1, facing: 5b, progress: 0.0f, y: 100, z: 0, source: 1b, id: "minecraft:piston", extending: 1b}"#,
+        );
+        let state = tag.get("blockState").unwrap();
+        assert_eq!(
+            pretty_piston(state, PistonPart::State).plain(),
+            r#"{id: "minecraft:piston_head", properties: {short: "false", facing: "east", type: "normal"}}"#,
+        );
+        let props = state.get("properties").unwrap();
+        assert_eq!(
+            pretty_piston(props, PistonPart::Properties).plain(),
+            r#"{short: "false", facing: "east", type: "normal"}"#,
+        );
+        assert_eq!(
+            pretty(props).plain(),
+            r#"{facing: "east", short: "false", type: "normal"}"#
+        );
+        assert_eq!(pretty(&tag).plain(), ordinary);
+    }
+    #[test]
    fn compact_form_matches_vanilla() {
        assert_eq!(
            rt("{b:1b,a:\"x\",c:[1,2],d:1.5f,e:2d,f:3L,g:4s}"),
@@ -0,0 +1,146 @@
+//! Every input the game names: vanilla's key mappings (`Options.keyMappings`) and Horizon's
+//! pad-only actions. Held state is asked by [`Action`] ([`crate::held::HeldKeys::held`]), not by a
+//! key: code that wants a mapping says which one, and every device that can hold it counts.
+use winit::keyboard::KeyCode;
+
+macro_rules! actions {
+    ($($variant:ident, $name:literal, $key:expr;)*) => {
+        /// A key mapping, or a pad-only action.
+        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+        pub enum Action {
+            $($variant,)*
+        }
+        impl Action {
+            /// In `Options.keyMappings` order, then Horizon's own mappings, the pad-only actions last.
+            pub const ALL: &[Action] = &[$(Action::$variant,)*];
+            /// The saved name: vanilla's for a mapping, `pad.*` for Horizon's own.
+            pub fn name(self) -> &'static str {
+                match self {
+                    $(Action::$variant => $name,)*
+                }
+            }
+            /// The default key the game's held state keeps this action under. `None` for what
+            /// isn't held as a key there: a mouse mapping, one with no default, a pad-only action,
+            /// and the debug keys, which act on the physical key (`debug_keys.rs`) and whose
+            /// defaults are other mappings' keys.
+            pub fn key(self) -> Option<KeyCode> {
+                match self {
+                    $(Action::$variant => $key,)*
+                }
+            }
+        }
+    };
+}
+
+actions! {
+    Attack, "key.attack", None;
+    Use, "key.use", None;
+    Forward, "key.forward", Some(KeyCode::KeyW);
+    Left, "key.left", Some(KeyCode::KeyA);
+    Back, "key.back", Some(KeyCode::KeyS);
+    Right, "key.right", Some(KeyCode::KeyD);
+    Jump, "key.jump", Some(KeyCode::Space);
+    Sneak, "key.sneak", Some(KeyCode::ShiftLeft);
+    Sprint, "key.sprint", Some(KeyCode::ControlLeft);
+    Drop, "key.drop", Some(KeyCode::KeyQ);
+    Inventory, "key.inventory", Some(KeyCode::KeyE);
+    Chat, "key.chat", Some(KeyCode::KeyT);
+    Playerlist, "key.playerlist", Some(KeyCode::Tab);
+    PickItem, "key.pickItem", None;
+    Command, "key.command", Some(KeyCode::Slash);
+    Friends, "key.friends", Some(KeyCode::KeyO);
+    SocialInteractions, "key.socialInteractions", Some(KeyCode::KeyP);
+    ToggleGui, "key.toggleGui", Some(KeyCode::F1);
+    ToggleSpectatorShaderEffects, "key.toggleSpectatorShaderEffects", Some(KeyCode::F4);
+    Screenshot, "key.screenshot", Some(KeyCode::F2);
+    TogglePerspective, "key.togglePerspective", Some(KeyCode::F5);
+    SmoothCamera, "key.smoothCamera", None;
+    Fullscreen, "key.fullscreen", Some(KeyCode::F11);
+    SpectatorOutlines, "key.spectatorOutlines", None;
+    SpectatorHotbar, "key.spectatorHotbar", None;
+    SwapOffhand, "key.swapOffhand", Some(KeyCode::KeyF);
+    SaveToolbarActivator, "key.saveToolbarActivator", Some(KeyCode::KeyC);
+    LoadToolbarActivator, "key.loadToolbarActivator", Some(KeyCode::KeyX);
+    Advancements, "key.advancements", Some(KeyCode::KeyL);
+    QuickActions, "key.quickActions", Some(KeyCode::KeyG);
+    DebugOverlay, "key.debug.overlay", None;
+    DebugModifier, "key.debug.modifier", None;
+    Hotbar1, "key.hotbar.1", Some(KeyCode::Digit1);
+    Hotbar2, "key.hotbar.2", Some(KeyCode::Digit2);
+    Hotbar3, "key.hotbar.3", Some(KeyCode::Digit3);
+    Hotbar4, "key.hotbar.4", Some(KeyCode::Digit4);
+    Hotbar5, "key.hotbar.5", Some(KeyCode::Digit5);
+    Hotbar6, "key.hotbar.6", Some(KeyCode::Digit6);
+    Hotbar7, "key.hotbar.7", Some(KeyCode::Digit7);
+    Hotbar8, "key.hotbar.8", Some(KeyCode::Digit8);
+    Hotbar9, "key.hotbar.9", Some(KeyCode::Digit9);
+    DebugReloadChunk, "key.debug.reloadChunk", None;
+    DebugShowHitboxes, "key.debug.showHitboxes", None;
+    DebugClearChat, "key.debug.clearChat", None;
+    DebugCrash, "key.debug.crash", None;
+    DebugShowChunkBorders, "key.debug.showChunkBorders", None;
+    DebugShowAdvancedTooltips, "key.debug.showAdvancedTooltips", None;
+    DebugCopyRecreateCommand, "key.debug.copyRecreateCommand", None;
+    DebugSpectate, "key.debug.spectate", None;
+    DebugSwitchGameMode, "key.debug.switchGameMode", None;
+    DebugDebugOptions, "key.debug.debugOptions", None;
+    DebugFocusPause, "key.debug.focusPause", None;
+    DebugDumpDynamicTextures, "key.debug.dumpDynamicTextures", None;
+    DebugReloadResourcePacks, "key.debug.reloadResourcePacks", None;
+    DebugProfiling, "key.debug.profiling", None;
+    DebugCopyLocation, "key.debug.copyLocation", None;
+    DebugDumpVersion, "key.debug.dumpVersion", None;
+    DebugProfilingChart, "key.debug.profilingChart", None;
+    DebugFpsCharts, "key.debug.fpsCharts", None;
+    DebugNetworkCharts, "key.debug.networkCharts", None;
+    DebugLightmapTexture, "key.debug.lightmapTexture", None;
+    DebugImprovedTransparency, "key.debug.improvedTransparency", None;
+    Emote, "key.emote", Some(KeyCode::KeyB);
+    HotbarPrevious, "pad.hotbarPrevious", None;
+    HotbarNext, "pad.hotbarNext", None;
+}
+
+impl Action {
+    pub fn parse(name: &str) -> Option<Self> {
+        Self::ALL.iter().copied().find(|a| a.name() == name)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::keybinds::{self, HORIZON_MAPPINGS, KeyBinds, MAPPINGS, all_mappings};
+
+    #[test]
+    fn every_mapping_is_an_action_in_order() {
+        let names: Vec<&str> = Action::ALL.iter().map(|a| a.name()).collect();
+        let mappings: Vec<&str> = MAPPINGS.iter().map(|m| m.0).collect();
+        assert_eq!(names[..mappings.len()], mappings[..]);
+        let horizon: Vec<&str> = HORIZON_MAPPINGS.iter().map(|m| m.0).collect();
+        let end = mappings.len() + horizon.len();
+        assert_eq!(names[mappings.len()..end], horizon[..]);
+        for action in &names[end..] {
+            assert!(action.starts_with("pad."), "{action}");
+        }
+    }
+
+    #[test]
+    fn an_actions_key_is_its_mappings_default_key() {
+        for (name, _, category) in all_mappings() {
+            let action = Action::parse(name).unwrap();
+            let want = if *category == "debug" {
+                None
+            } else {
+                keybinds::key_code(KeyBinds::default_of(name))
+            };
+            assert_eq!(action.key(), want, "{name}");
+        }
+    }
+
+    #[test]
+    fn every_bindable_action_is_an_action() {
+        for (name, _) in crate::gamepad::ACTIONS {
+            assert!(Action::parse(name).is_some(), "{name}");
+        }
+    }
+}
@@ -1,11 +1,17 @@
 //! Controllers: Horizon's own feature (vanilla 26.3 has no gamepad input).
-//! The default layout is Bedrock Edition's; see docs/controllers.md.
+//! Its default buttons are Horizon's own; analog walking and toggle sneak follow Bedrock Edition on
+//! consoles. See docs/controllers.md.
 //!
 //! This module is the backend-free part: positional buttons, the action
 //! bindings, deadzones and the look curve, button edges from successive pad
 //! states, and `horizon-controller.txt`, kept next to `options.txt` so that
 //! file stays exactly vanilla's. The game reads the pads with gilrs.
-use std::{collections::BTreeMap, fs, path::Path};
+use std::{
+    collections::BTreeMap,
+    fs,
+    path::Path,
+    time::{Duration, Instant},
+};

 pub const FILE: &str = "horizon-controller.txt";

@@ -119,6 +125,19 @@ impl Button {
            ][face],
        }
    }
+    /// The face button that plays this one's part on a Nintendo pad going by its letters
+    /// (`PadSettings::nintendo_letters`): the A it prints on the right is South, which confirms
+    /// and jumps as A does on a Switch; B (bottom) is East, X (top) West, Y (left) North. It is
+    /// its own inverse, so it turns a part into the button playing it and back.
+    pub fn by_letter(self) -> Button {
+        match self {
+            Button::South => Button::East,
+            Button::East => Button::South,
+            Button::West => Button::North,
+            Button::North => Button::West,
+            other => other,
+        }
+    }
 }

 /// A pad's inputs at one moment. Sticks are `[x, y]` with right and up
@@ -142,6 +161,14 @@ impl PadState {
    pub fn held(&self, button: Button) -> bool {
        self.buttons & button.bit() != 0
    }
+    /// A Nintendo pad's buttons read by their letters (`Button::by_letter`).
+    pub fn by_letter(&self) -> PadState {
+        let mut state = *self;
+        for part in [Button::South, Button::East, Button::West, Button::North] {
+            state.set(part, self.held(part.by_letter()));
+        }
+        state
+    }
    /// Two sources at once (a real pad and `horizon-ctl pad`): buttons held on
    /// either, sticks and triggers added.
    pub fn merge(&self, other: &PadState) -> PadState {
@@ -275,7 +302,7 @@ pub const HOTBAR_NEXT: &str = "pad.hotbarNext";
 /// always pause / back and isn't listed.
 pub const ACTIONS: &[(&str, Option<Button>)] = &[
    ("key.jump", Some(Button::South)),
-    ("key.drop", Some(Button::East)),
+    ("key.drop", Some(Button::DPadDown)),
    ("key.swapOffhand", Some(Button::West)),
    ("key.inventory", Some(Button::North)),
    (HOTBAR_PREVIOUS, Some(Button::LeftBumper)),
@@ -284,15 +311,31 @@ pub const ACTIONS: &[(&str, Option<Button>)] = &[
    ("key.attack", Some(Button::RightTrigger)),
    ("key.sprint", Some(Button::LeftStick)),
    ("key.sneak", Some(Button::RightStick)),
-    ("key.togglePerspective", Some(Button::DPadUp)),
+    ("key.togglePerspective", Some(Button::Select)),
    ("key.pickItem", Some(Button::DPadLeft)),
-    ("key.chat", Some(Button::DPadRight)),
-    ("key.advancements", Some(Button::DPadDown)),
-    ("key.playerlist", Some(Button::Select)),
+    ("key.chat", Some(Button::DPadUp)),
+    ("key.advancements", None),
+    ("key.playerlist", None),
    ("key.command", None),
    ("key.screenshot", None),
    ("key.toggleGui", None),
    ("key.smoothCamera", None),
+    // Horizon's emote wheel: no button is free by default; the stick's cursor picks.
+    ("key.emote", None),
+    ("key.fullscreen", None),
+    ("key.socialInteractions", None),
+    ("key.quickActions", None),
+    ("key.saveToolbarActivator", None),
+    ("key.loadToolbarActivator", None),
+    ("key.hotbar.1", None),
+    ("key.hotbar.2", None),
+    ("key.hotbar.3", None),
+    ("key.hotbar.4", None),
+    ("key.hotbar.5", None),
+    ("key.hotbar.6", None),
+    ("key.hotbar.7", None),
+    ("key.hotbar.8", None),
+    ("key.hotbar.9", None),
 ];

 /// How a bindable action reaches the game: one of its own handlers, shared
@@ -307,6 +350,10 @@ pub enum Route {
    Sneak,
    Screenshot,
    SmoothCamera,
+    Fullscreen,
+    /// Does nothing by itself: what reads it asks whether the button is held
+    /// (`Minecraft.handleKeybinds`' toolbar keys, held with a hotbar key).
+    Held,
    Key(winit::keyboard::KeyCode),
    Mouse(winit::event::MouseButton),
 }
@@ -319,6 +366,8 @@ pub fn route(action: &str) -> Option<Route> {
        "key.sneak" => Some(Route::Sneak),
        "key.screenshot" => Some(Route::Screenshot),
        "key.smoothCamera" => Some(Route::SmoothCamera),
+        "key.fullscreen" => Some(Route::Fullscreen),
+        "key.saveToolbarActivator" | "key.loadToolbarActivator" => Some(Route::Held),
        _ => {
            let default = crate::keybinds::KeyBinds::default_of(action);
            crate::keybinds::mouse_button(default)
@@ -338,6 +387,46 @@ pub fn action_caption(action: &str) -> &str {
    }
 }

+/// How long a held drop button throws single items before it throws the rest of the stack.
+pub const DROP_STACK_HOLD: Duration = Duration::from_secs(1);
+
+/// What a held drop button does now, past its press.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DropStep {
+    /// Held key.drop (a repeat reaches `KeyMapping.click` as a press).
+    One,
+    /// Control + key.drop: a pad has no Control to hold, so holding on is how it asks.
+    Stack,
+}
+
+/// A held drop button's repeats: a tap throws one item, as Q does; held, it repeats at the pad's
+/// repeat delay and interval; and held for [`DROP_STACK_HOLD`] it throws what's left.
+#[derive(Clone, Copy, Debug)]
+pub struct HeldDrop {
+    since: Instant,
+    next: Instant,
+}
+impl HeldDrop {
+    pub fn new(now: Instant, delay: Duration) -> Self {
+        Self {
+            since: now,
+            next: now + delay,
+        }
+    }
+    /// The step due at `now`, if any; at most one per call.
+    pub fn due(&mut self, now: Instant, interval: Duration) -> Option<DropStep> {
+        if now < self.next {
+            return None;
+        }
+        self.next = now + interval;
+        Some(if now.duration_since(self.since) >= DROP_STACK_HOLD {
+            DropStep::Stack
+        } else {
+            DropStep::One
+        })
+    }
+}
+
 /// Which button pictures prompts use.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum GlyphStyle {
@@ -381,13 +470,21 @@ impl GlyphStyle {
        GlyphStyle::PlayStation,
        GlyphStyle::Nintendo,
    ];
-    /// The style for a pad by its USB vendor (Sony, Nintendo; Microsoft,
-    /// Valve's Steam Deck and Steam Input's virtual pad, and everything else
-    /// look like Xbox).
-    pub fn of_vendor(vendor: Option<u16>) -> Self {
-        match vendor {
-            Some(0x054c) => GlyphStyle::PlayStation,
-            Some(0x057e) => GlyphStyle::Nintendo,
+    /// The style for a pad by its USB ids: Sony's and Nintendo's own, and a few officially licensed
+    /// third-party pads made for their consoles. Microsoft, Valve's Steam Deck and Steam Input's
+    /// virtual pad, and everything else look like Xbox.
+    pub fn of_device(vendor: Option<u16>, product: Option<u16>) -> Self {
+        match (vendor, product) {
+            (Some(0x054c), _) => GlyphStyle::PlayStation,
+            (Some(0x057e), _) => GlyphStyle::Nintendo,
+            // HORIPAD 4 FPS and FPS Plus; Razer Raiju; Nacon Revolution Pro.
+            (Some(0x0f0d), Some(0x0055 | 0x0066))
+            | (Some(0x1532), Some(0x1000))
+            | (Some(0x146b), Some(0x0d01)) => GlyphStyle::PlayStation,
+            // HORIPAD for Nintendo Switch; PowerA Wired Plus; PDP Faceoff Wired Pro.
+            (Some(0x0f0d), Some(0x00c1))
+            | (Some(0x20d6), Some(0xa711))
+            | (Some(0x0e6f), Some(0x0180)) => GlyphStyle::Nintendo,
            _ => GlyphStyle::Xbox,
        }
    }
@@ -454,6 +551,10 @@ pub struct PadSettings {
    /// holding it, unless vanilla's toggle crouch is on already.
    pub toggle_sneak: bool,
    pub glyphs: GlyphStyle,
+    /// A Nintendo pad's face buttons go by their letters (A confirms and jumps, as on the
+    /// Switch's own menus and keyboard) instead of their places (B, at the bottom, does): on
+    /// by default on the Switch only.
+    pub nintendo_letters: bool,
    pub keyboard: TextKeyboard,
    /// Menu pointer multiplier, scroll lines/second, and repeat times in seconds.
    pub pointer_speed: f32,
@@ -478,6 +579,7 @@ impl Default for PadSettings {
            trigger_threshold: 0.4,
            toggle_sneak: true,
            glyphs: GlyphStyle::Auto,
+            nintendo_letters: cfg!(target_os = "horizon"),
            keyboard: TextKeyboard::Auto,
            pointer_speed: 1.0,
            scroll_speed: 12.0,
@@ -545,6 +647,7 @@ impl PadSettings {
                }
                "toggleSneak" => s.toggle_sneak = flag(s.toggle_sneak),
                "glyphs" => s.glyphs = GlyphStyle::parse(value),
+                "nintendoLetters" => s.nintendo_letters = flag(s.nintendo_letters),
                "keyboard" => s.keyboard = TextKeyboard::parse(value),
                "pointerSpeed" => s.pointer_speed = bounded(s.pointer_speed, 0.25, 3.0),
                "scrollSpeed" => s.scroll_speed = bounded(s.scroll_speed, 1.0, 36.0),
@@ -564,11 +667,29 @@ impl PadSettings {
                }
            }
        }
+        // A file from before these defaults: its player's buttons stay where they were.
+        if !text.is_empty() && !text.lines().any(|line| line.starts_with("bindLayout:")) {
+            for (action, button) in [
+                ("key.drop", Button::East),
+                ("key.togglePerspective", Button::DPadUp),
+                ("key.chat", Button::DPadRight),
+                ("key.playerlist", Button::Select),
+                ("key.advancements", Button::DPadDown),
+            ] {
+                // A button saved by hand stays, even one that's now this action's default.
+                if !text
+                    .lines()
+                    .any(|line| line.starts_with(&format!("bind_{action}:")))
+                {
+                    s.bindings.entry(action).or_insert(Some(button));
+                }
+            }
+        }
        s
    }
    pub fn serialize(&self) -> String {
        let mut text = format!(
-            "enabled:{}\nvibration:{}\nadaptiveTriggers:{}\nlightbar:{}\nlookSensitivity:{}\ninvertX:{}\ninvertY:{}\nmoveDeadzone:{}\nlookDeadzone:{}\ntriggerThreshold:{}\ntoggleSneak:{}\nglyphs:{}\nkeyboard:{}\n",
+            "enabled:{}\nvibration:{}\nadaptiveTriggers:{}\nlightbar:{}\nlookSensitivity:{}\ninvertX:{}\ninvertY:{}\nmoveDeadzone:{}\nlookDeadzone:{}\ntriggerThreshold:{}\ntoggleSneak:{}\nglyphs:{}\nnintendoLetters:{}\nkeyboard:{}\n",
            bool_text(self.enabled),
            bool_text(self.vibration),
            bool_text(self.adaptive_triggers),
@@ -581,6 +702,7 @@ impl PadSettings {
            self.trigger_threshold,
            bool_text(self.toggle_sneak),
            self.glyphs.name(),
+            bool_text(self.nintendo_letters),
            self.keyboard.name(),
        );
        text.push_str(&format!(
@@ -593,6 +715,7 @@ impl PadSettings {
                button.map_or("none", Button::name)
            ));
        }
+        text.push_str("bindLayout:1\n");
        text
    }
    pub fn default_of(action: &str) -> Option<Button> {
@@ -669,6 +792,29 @@ pub fn stick_axes(
    }
 }

+/// The tilt from which a stick holds a key in [`eight_direction_keys`]: holding one is full speed,
+/// so the small tilts past the deadzone stay still.
+const KEY_TILT: f32 = 0.3;
+/// tan(22.5 degrees): where one of the 8 sectors meets the next.
+const SECTOR_EDGE: f32 = 0.414_213_57;
+
+/// The movement keys (forward, backward, left, right) a move vector (`[left, forward]`) holds: the
+/// one of the 8 headings it is nearest, so it is at most 22.5 degrees off. An edge goes to the
+/// straight heading.
+pub fn eight_direction_keys([left, forward]: [f32; 2]) -> [bool; 4] {
+    if length([left, forward]) < KEY_TILT {
+        return [false; 4];
+    }
+    let along = forward.abs() > SECTOR_EDGE * left.abs();
+    let across = left.abs() > SECTOR_EDGE * forward.abs();
+    [
+        along && forward > 0.0,
+        along && forward < 0.0,
+        across && left > 0.0,
+        across && left < 0.0,
+    ]
+}
+
 /// A radial deadzone: inside it the stick is centred; beyond it the rest of
 /// the travel is rescaled to 0..1 in the same direction, so diagonals aren't
 /// clipped and the first movement past the deadzone is small.
@@ -717,15 +863,6 @@ pub fn look_delta(
    )
 }

-/// The hotbar slot after a bumper: one step with wrap-around.
-pub fn hotbar_step(selected: usize, forward: bool) -> usize {
-    if forward {
-        (selected + 1) % 9
-    } else {
-        (selected + 8) % 9
-    }
-}
-
 /// Menu cursor speed in GUI pixels per second at full tilt.
 pub const CURSOR_SPEED: f32 = 300.0;

@@ -787,6 +924,98 @@ pub fn stick_direction(stick: [f32; 2], threshold: f32) -> Option<Button> {
    })
 }

+/// How far a stick already stepping must fall back to let go: between this and
+/// the step threshold it holds its direction, so a stick resting on the
+/// threshold doesn't step again.
+pub const STICK_RELEASE: f32 = 0.35;
+/// How much more a stick must lean along another axis to change direction, so
+/// a stick resting on a diagonal doesn't flip between the two.
+const STICK_TURN: f32 = 1.5;
+
+/// [`stick_direction`] for a stick that may already be stepping `held`: it stays
+/// that way until the stick falls back past [`STICK_RELEASE`] or clearly turns.
+pub fn stick_direction_held(
+    stick: [f32; 2],
+    threshold: f32,
+    held: Option<Button>,
+) -> Option<Button> {
+    let fresh = stick_direction(stick, threshold);
+    let Some((axis, positive)) = held.and_then(direction) else {
+        return fresh;
+    };
+    if length(stick) < STICK_RELEASE {
+        return None;
+    }
+    // `direction`'s y runs down the screen, a stick's up.
+    let toward = stick[axis] * if positive == (axis == 0) { 1.0 } else { -1.0 };
+    if toward > 0.0 && stick[1 - axis].abs() <= toward * STICK_TURN {
+        held
+    } else {
+        fresh
+    }
+}
+
+/// A list drawn with a scrollbar (`ui::scrollbar`), how far it is scrolled (a list
+/// moving a whole row a notch draws the same rectangles, so they can't tell) and
+/// the ways it can still scroll.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct ScrollArea {
+    pub rect: Rect,
+    pub amount: f32,
+    pub up: bool,
+    pub down: bool,
+}
+
+impl ScrollArea {
+    /// A row counts while any of it is in view: the stick can leave the focus on one nearly gone.
+    pub fn holds(&self, r: &Rect) -> bool {
+        let x = r[0] + r[2] / 2.0;
+        let [ax, ay, aw, ah] = self.rect;
+        (ax..ax + aw).contains(&x) && r[1] < ay + ah && r[1] + r[3] > ay
+    }
+    /// All of a row is in view.
+    fn shows(&self, r: &Rect) -> bool {
+        let [_, ay, _, ah] = self.rect;
+        self.holds(r) && r[1] + 0.5 >= ay && r[1] + r[3] <= ay + ah + 0.5
+    }
+}
+
+/// A vertical focus step, with lists: the strict step, unless it would land
+/// outside the view of the list `from` is in, or only partly in it, while that
+/// list can still scroll that way, when there is none (`None`) and the list
+/// scrolls instead: its hidden rows come first and whole, as vanilla's arrow
+/// keys walk a selection list's entries (`ensureVisible`).
+pub fn list_step(
+    from: Rect,
+    button: Button,
+    targets: &[Rect],
+    areas: &[ScrollArea],
+) -> Option<usize> {
+    let step = focus_step_strict(from, button, targets)?;
+    let can_scroll = |a: &ScrollArea| {
+        if button == Button::DPadUp {
+            a.up
+        } else {
+            a.down
+        }
+    };
+    let leaves = areas
+        .iter()
+        .find(|a| a.holds(&from))
+        .is_some_and(|a| can_scroll(a) && !a.shows(&targets[step]));
+    (!leaves).then_some(step)
+}
+
+/// The farthest centres of two neighbouring slots: 18 apart, 22 over the hotbar's gap.
+const SLOT_NEIGHBOUR: f32 = 24.0;
+
+/// A held direction's repeat stops at the edge of the slots it is walking: it
+/// goes on only from a slot to a slot next to it (the hotbar's small gap
+/// included). A fresh press may go anywhere.
+pub fn repeat_crosses_slots(from: (f32, f32), to: (f32, f32), to_slot: bool) -> bool {
+    !to_slot || (to.0 - from.0).abs().max((to.1 - from.1).abs()) > SLOT_NEIGHBOUR
+}
+
 /// Arrow-key focus navigation as vanilla does it
 /// (`ContainerEventHandler.nextFocusPathInDirection`), over every target of
 /// the screen at once: from a strip one pixel past the focused edge, the
@@ -882,12 +1111,25 @@ pub fn focus_step_vague(from: Rect, button: Button, targets: &[Rect]) -> Option<

 /// How far a list scrolled between two frames' targets: the vertical shift
 /// most targets of the same position and size agree on (targets that didn't
-/// move, outside the list, don't count). `None` when nothing moved.
-pub fn scroll_shift(before: &[Rect], after: &[Rect]) -> Option<f32> {
+/// move, outside the list, don't count), for a list scrolled towards its end
+/// (`down`: the rows moved up) or its start. `None` when nothing moved that way.
+/// It takes the direction because half a row's scroll votes the same both ways.
+pub fn scroll_shift(before: &[Rect], after: &[Rect], down: bool) -> Option<f32> {
    let same = |a: &Rect, b: &Rect| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 0.5);
    if before.len() == after.len() && before.iter().zip(after).all(|(a, b)| same(a, b)) {
        return None;
    }
+    // Most votes; among equals the smallest move (the next row, not a far one).
+    shift_votes(before, after)
+        .into_iter()
+        .filter(|v| (v.0 < 0.0) == down)
+        .max_by(|a, b| a.1.cmp(&b.1).then(b.0.abs().total_cmp(&a.0.abs())))
+        .map(|v| v.0)
+}
+
+/// Every vertical shift that would carry a `before` target onto an `after`
+/// target of the same position and size, with how many it would.
+fn shift_votes(before: &[Rect], after: &[Rect]) -> Vec<(f32, usize)> {
    let mut votes: Vec<(f32, usize)> = Vec::new();
    for b in before {
        for a in after {
@@ -904,11 +1146,94 @@ pub fn scroll_shift(before: &[Rect], after: &[Rect]) -> Option<f32> {
            }
        }
    }
-    // Most votes; among equals the smallest move (the next row, not a far one).
    votes
+}
+
+/// Where the focus goes when the right stick scrolled a list (`down`: towards
+/// its end, so the rows moved up): the rectangle moved by the list's shift;
+/// the same rectangle, for a widget outside the list; or, its row out of view,
+/// the nearest target of its kind (`after`'s flag), the list's rows before
+/// anything fixed. `None` when nothing moved that way, or none of its kind is
+/// left. It takes the direction because half a row's scroll votes the same
+/// both ways once a new row comes into view.
+pub fn follow_scroll(
+    focus: Rect,
+    down: bool,
+    before: &[Rect],
+    after: &[(Rect, bool)],
+) -> Option<usize> {
+    let rects: Vec<Rect> = after.iter().map(|t| t.0).collect();
+    // A column that stayed put isn't the list, even spaced like its shift.
+    let column = |of: &[Rect], r: &Rect| -> Vec<f32> {
+        let same = |o: &&Rect| o[0] == r[0] && o[2] == r[2] && o[3] == r[3];
+        of.iter().filter(same).map(|o| o[1]).collect()
+    };
+    let moving = |r: &&Rect| column(before, r) != column(&rects, r);
+    let was: Vec<Rect> = before.iter().filter(moving).copied().collect();
+    let now: Vec<Rect> = rects.iter().filter(moving).copied().collect();
+    let dy = shift_votes(&was, &now)
        .into_iter()
-        .max_by(|a, b| a.1.cmp(&b.1).then(b.0.abs().total_cmp(&a.0.abs())))
-        .map(|v| v.0)
+        .filter(|v| (v.0 < 0.0) == down)
+        .max_by(|a, b| a.1.cmp(&b.1).then(b.0.abs().total_cmp(&a.0.abs())))?
+        .0;
+    let same = |a: &Rect, b: &Rect| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 0.5);
+    let moved = [focus[0], focus[1] + dy, focus[2], focus[3]];
+    let found = |at: &Rect| rects.iter().position(|r| same(r, at));
+    if !moving(&&focus) {
+        return found(&focus);
+    }
+    if let Some(i) = found(&moved).or_else(|| found(&focus)) {
+        return Some(i);
+    }
+    let in_list = |r: &Rect| {
+        let was = [r[0], r[1] - dy, r[2], r[3]];
+        before.iter().any(|b| same(b, &was))
+    };
+    let centre = (moved[0] + moved[2] / 2.0, moved[1] + moved[3] / 2.0);
+    let distance = |r: &Rect| (r[0] + r[2] / 2.0 - centre.0).hypot(r[1] + r[3] / 2.0 - centre.1);
+    after
+        .iter()
+        .enumerate()
+        .filter(|(_, t)| t.1)
+        .min_by(|(_, a), (_, b)| {
+            in_list(&b.0)
+                .cmp(&in_list(&a.0))
+                .then(distance(&a.0).total_cmp(&distance(&b.0)))
+        })
+        .map(|(i, _)| i)
+}
+
+/// The target a focus rectangle stands for once the screen's size changed:
+/// the same widget, by its place in the draw order when the screen drew as
+/// many; else the target nearest where its centre falls at the new size.
+pub fn refind_resized(
+    focus: Rect,
+    before: &[Rect],
+    after: &[Rect],
+    old: (f32, f32),
+    new: (f32, f32),
+) -> Option<usize> {
+    let same = |r: &Rect| r.iter().zip(&focus).all(|(a, b)| (a - b).abs() < 0.5);
+    if before.len() == after.len()
+        && let Some(i) = before.iter().position(same)
+    {
+        return Some(i);
+    }
+    let at = rescaled(
+        (focus[0] + focus[2] / 2.0, focus[1] + focus[3] / 2.0),
+        old,
+        new,
+    );
+    let centres: Vec<(f32, f32)> = after
+        .iter()
+        .map(|r| (r[0] + r[2] / 2.0, r[1] + r[3] / 2.0))
+        .collect();
+    nearest(at, &centres, f32::INFINITY)
+}
+
+/// A point at the same place, proportionally, on a screen of another size.
+pub fn rescaled(at: (f32, f32), old: (f32, f32), new: (f32, f32)) -> (f32, f32) {
+    (at.0 * new.0 / old.0.max(1.0), at.1 * new.1 / old.1.max(1.0))
 }

 /// The target a remembered focus rectangle stands for in a new frame: the
@@ -1244,6 +1569,52 @@ mod tests {
        }
    }

+    #[test]
+    fn a_held_drop_repeats_then_throws_the_stack() {
+        let t = Instant::now();
+        let at = |ms: u64| t + Duration::from_millis(ms);
+        let (delay, interval) = (Duration::from_millis(350), Duration::from_millis(90));
+        let mut held = HeldDrop::new(t, delay);
+        assert_eq!(held.due(at(100), interval), None, "a tap is one item");
+        assert_eq!(held.due(at(349), interval), None);
+        assert_eq!(held.due(at(350), interval), Some(DropStep::One));
+        assert_eq!(held.due(at(400), interval), None, "not before the interval");
+        assert_eq!(held.due(at(440), interval), Some(DropStep::One));
+        assert_eq!(held.due(at(999), interval), Some(DropStep::One));
+        assert_eq!(held.due(at(1000), interval), None);
+        assert_eq!(held.due(at(1100), interval), Some(DropStep::Stack));
+        assert_eq!(held.due(at(1200), interval), Some(DropStep::Stack));
+        assert_eq!(held.due(at(1201), interval), None);
+    }
+
+    #[test]
+    fn the_later_actions_have_no_default_button_and_leave_saved_bindings() {
+        let defaults = PadSettings::default();
+        for action in [
+            "key.fullscreen",
+            "key.socialInteractions",
+            "key.quickActions",
+            "key.saveToolbarActivator",
+            "key.loadToolbarActivator",
+            "key.hotbar.1",
+            "key.hotbar.9",
+        ] {
+            assert_eq!(defaults.binding(action), None, "{action}");
+        }
+        let read = PadSettings::parse(
+            "bindLayout:1
+bind_key.jump:east
+bind_key.hotbar.2:north
+",
+        );
+        assert_eq!(read.binding("key.jump"), Some(Button::East));
+        assert_eq!(read.binding("key.inventory"), Some(Button::North));
+        assert_eq!(
+            read.actions_of(Button::North),
+            ["key.inventory", "key.hotbar.2"]
+        );
+    }
+
    #[test]
    fn navigation_preferences_migrate_and_stay_with_each_player() {
        let dir = std::env::temp_dir().join(format!(
@@ -1363,7 +1734,7 @@ mod tests {
    }

    #[test]
-    fn defaults_follow_bedrock() {
+    fn every_action_has_its_default() {
        let s = PadSettings::default();
        assert_eq!(s.actions_of(Button::South), ["key.jump"]);
        assert_eq!(s.actions_of(Button::RightTrigger), ["key.attack"]);
@@ -1371,16 +1742,46 @@ mod tests {
        assert_eq!(s.actions_of(Button::North), ["key.inventory"]);
        assert_eq!(s.actions_of(Button::RightBumper), [HOTBAR_NEXT]);
        assert!(s.actions_of(Button::Start).is_empty());
-        // Every default action names a vanilla mapping or a pad action.
+        // Every default action names a key mapping or a pad action.
        for (action, _) in ACTIONS {
            assert!(
                action.starts_with("pad.")
-                    || crate::keybinds::MAPPINGS.iter().any(|m| m.0 == *action),
+                    || crate::keybinds::all_mappings().any(|m| m.0 == *action),
                "{action}"
            );
        }
    }

+    #[test]
+    fn a_file_from_before_these_defaults_keeps_its_buttons() {
+        // Saved settings that never bound D-pad down: it stays on the advancements.
+        let s = PadSettings::parse("vibration:false\nbind_key.chat:up\n");
+        assert_eq!(s.binding("key.advancements"), Some(Button::DPadDown));
+        assert_eq!(s.binding("key.chat"), Some(Button::DPadUp));
+        assert_eq!(s.binding("key.drop"), Some(Button::East));
+        assert_eq!(s.binding("key.togglePerspective"), Some(Button::DPadUp));
+        assert_eq!(s.binding("key.playerlist"), Some(Button::Select));
+        assert!(!s.conflicts("key.advancements"));
+        // Advancements moved by hand stays moved, and the file stays this way from then on.
+        let s = PadSettings::parse("bind_key.advancements:left\nbind_key.drop:down\n");
+        assert_eq!(s.binding("key.advancements"), Some(Button::DPadLeft));
+        assert_eq!(s.binding("key.drop"), Some(Button::DPadDown));
+        assert_eq!(PadSettings::parse(&s.serialize()), s);
+    }
+
+    #[test]
+    fn a_new_player_drops_on_d_pad_down_and_chats_on_d_pad_up() {
+        for s in [PadSettings::default(), PadSettings::parse("")] {
+            assert_eq!(s.binding("key.drop"), Some(Button::DPadDown));
+            assert_eq!(s.binding("key.chat"), Some(Button::DPadUp));
+            assert_eq!(s.binding("key.togglePerspective"), Some(Button::Select));
+            assert_eq!(s.binding("key.playerlist"), None);
+            assert_eq!(s.binding("key.advancements"), None);
+        }
+        let s = PadSettings::parse(&PadSettings::default().serialize());
+        assert_eq!(s, PadSettings::default());
+    }
+
    #[test]
    fn settings_round_trip_and_store_only_changes() {
        let mut s = PadSettings::default();
@@ -1391,7 +1792,9 @@ mod tests {
        s.invert_y = true;
        s.look_sensitivity = 0.75;
        s.glyphs = GlyphStyle::PlayStation;
+        s.nintendo_letters = !s.nintendo_letters;
        let text = s.serialize();
+        assert!(text.contains(&format!("nintendoLetters:{}\n", s.nintendo_letters)));
        assert!(text.contains("bind_key.jump:east\n"));
        assert!(text.contains("bind_key.drop:none\n"));
        assert!(!text.contains("key.sneak"));
@@ -1400,8 +1803,9 @@ mod tests {
        assert_eq!(back.binding("key.drop"), None);
        assert_eq!(back.actions_of(Button::East), ["key.jump"]);
        // Garbage keeps the defaults.
-        let odd =
-            PadSettings::parse("lookSensitivity:NaN\nbind_key.nope:south\nbind_key.jump:x9\n");
+        let odd = PadSettings::parse(
+            "lookSensitivity:NaN\nbind_key.nope:south\nbind_key.jump:x9\nbindLayout:1\n",
+        );
        assert_eq!(odd, PadSettings::default());
    }

@@ -1437,6 +1841,84 @@ mod tests {
        assert_eq!(other, ([0.0, 0.0], [1.0, 0.0]));
    }

+    #[test]
+    fn a_nintendo_pad_by_its_letters_confirms_with_a() {
+        // The pad's A sits on the right (East): going by letters it plays South, confirm and jump.
+        let mut pad = PadState::default();
+        pad.set(Button::East, true);
+        pad.set(Button::LeftBumper, true);
+        pad.left = [0.5, -0.25];
+        let parts = pad.by_letter();
+        assert!(parts.held(Button::South));
+        assert!(!parts.held(Button::East));
+        // Other buttons and the sticks stay; reading by letters again gives the pad back.
+        assert!(parts.held(Button::LeftBumper));
+        assert_eq!(parts.left, [0.5, -0.25]);
+        assert_eq!(parts.by_letter(), pad);
+        // A part's glyph is the letter of the button playing it.
+        assert_eq!(Button::South.by_letter().label(GlyphStyle::Nintendo), "A");
+        assert_eq!(Button::East.by_letter().label(GlyphStyle::Nintendo), "B");
+        assert_eq!(Button::West.by_letter().label(GlyphStyle::Nintendo), "X");
+        assert_eq!(Button::North.by_letter().label(GlyphStyle::Nintendo), "Y");
+    }
+
+    #[test]
+    fn a_stick_holds_the_keys_of_its_nearest_heading() {
+        // Forward, backward, left, right, by the heading counted from forward toward left.
+        let headings = [
+            [true, false, false, false],
+            [true, false, true, false],
+            [false, false, true, false],
+            [false, true, true, false],
+            [false, true, false, false],
+            [false, true, false, true],
+            [false, false, false, true],
+            [true, false, false, true],
+        ];
+        for tenth in 0..3600 {
+            let degrees = tenth as f32 / 10.0;
+            if degrees % 45.0 == 22.5 {
+                continue;
+            }
+            for tilt in [0.31, 0.5, 1.0] {
+                let (s, c) = degrees.to_radians().sin_cos();
+                let keys = eight_direction_keys([tilt * s, tilt * c]);
+                let sector = ((degrees / 45.0).round() as usize) % 8;
+                assert_eq!(keys, headings[sector], "{degrees} at {tilt}");
+                let [left, forward] =
+                    crate::input::keyboard_direction(keys[0], keys[1], keys[2], keys[3]);
+                let off = (left.atan2(forward).to_degrees() - degrees).rem_euclid(360.0);
+                assert!(off.min(360.0 - off) <= 22.5 + 1e-3, "{degrees}: {off}");
+            }
+        }
+    }
+
+    #[test]
+    fn a_sector_edge_goes_to_the_straight_heading() {
+        assert_eq!(
+            eight_direction_keys([0.414_213_57, 1.0]),
+            [true, false, false, false]
+        );
+        assert_eq!(
+            eight_direction_keys([0.4143, 1.0]),
+            [true, false, true, false]
+        );
+        assert_eq!(
+            eight_direction_keys([1.0, 0.414_213_57]),
+            [false, false, true, false]
+        );
+    }
+
+    #[test]
+    fn a_small_tilt_holds_no_key() {
+        assert_eq!(eight_direction_keys([0.0, 0.0]), [false; 4]);
+        assert_eq!(eight_direction_keys([0.2, 0.2]), [false; 4]);
+        assert_eq!(
+            eight_direction_keys([0.0, 0.31]),
+            [true, false, false, false]
+        );
+    }
+
    #[test]
    fn radial_deadzone_rescales() {
        assert_eq!(radial([0.1, 0.05], 0.15), [0.0, 0.0]);
@@ -1581,6 +2063,63 @@ mod tests {
        assert_eq!(focus_step_rect(grid[0], Button::South, &grid), None);
    }

+    #[test]
+    fn follow_scroll_keeps_rows_and_fixed_widgets() {
+        // Rows 36 tall scrolled down 18: a fifth row comes into view, so +18
+        // carries as many rows as the real -18. Back, below, stays.
+        let back = [296.0, 212.0, 71.0, 20.0];
+        let rows = |ys: &[f32]| -> Vec<(Rect, bool)> {
+            let rows = ys.iter().map(|y| ([78.0, *y, 270.0, 36.0], true));
+            rows.chain([(back, false)]).collect()
+        };
+        let rects = |t: &[(Rect, bool)]| -> Vec<Rect> { t.iter().map(|t| t.0).collect() };
+        let before = rects(&rows(&[33.0, 69.0, 105.0, 141.0]));
+        let after = rows(&[15.0, 51.0, 87.0, 123.0, 159.0]);
+        assert_eq!(follow_scroll(before[1], true, &before, &after), Some(1));
+        assert_eq!(follow_scroll(back, true, &before, &after), Some(5));
+        // And back up.
+        let up = rows(&[33.0, 69.0, 105.0, 141.0]);
+        let was = rects(&after);
+        assert_eq!(follow_scroll(was[2], false, &was, &up), Some(2));
+        // Nothing moved, as on a screen with no list.
+        let still = rows(&[33.0, 69.0, 105.0, 141.0]);
+        assert_eq!(follow_scroll(before[1], true, &before, &still), None);
+        // A sidebar's tabs spaced exactly like the list's shift stay put.
+        let tab = |y: f32| [8.0, y, 112.0, 16.0];
+        let with_tabs = |t: &[(Rect, bool)]| -> Vec<(Rect, bool)> {
+            t.iter()
+                .copied()
+                .chain([(tab(100.0), true), (tab(118.0), true)])
+                .collect()
+        };
+        let was = rects(&with_tabs(&rows(&[33.0, 69.0, 105.0, 141.0])));
+        let now = with_tabs(&after);
+        assert_eq!(follow_scroll(tab(118.0), true, &was, &now), Some(7));
+    }
+
+    #[test]
+    fn follow_scroll_lands_on_the_nearest_row_when_its_row_leaves() {
+        // The row at 33 left the top; the next one is at 51. Nothing fixed.
+        let row = |y: f32| [78.0, y, 270.0, 36.0];
+        let before = [row(33.0), row(69.0), row(105.0)];
+        let after = [(row(51.0), true), (row(87.0), true)];
+        assert_eq!(follow_scroll(row(33.0), true, &before, &after), Some(0));
+        // The last row left the bottom: the list's new last row, not a fixed
+        // widget of its kind (at 200) nearer where the row went.
+        let fixed = [78.0, 200.0, 270.0, 36.0];
+        let before = [row(15.0), row(51.0), row(87.0), row(159.0), fixed];
+        let after = [
+            (row(33.0), true),
+            (row(69.0), true),
+            (row(105.0), true),
+            (fixed, true),
+        ];
+        assert_eq!(follow_scroll(row(159.0), false, &before, &after), Some(2));
+        // Nothing of its kind left.
+        let other = after.map(|t| (t.0, false));
+        assert_eq!(follow_scroll(row(159.0), false, &before, &other), None);
+    }
+
    #[test]
    fn refind_tabs_sliders_and_stick_steps() {
        let rects: Vec<Rect> = vec![[0.0, 0.0, 10.0, 10.0], [0.0, 20.0, 10.0, 10.0]];
@@ -1597,8 +2136,10 @@ mod tests {
            .map(|i| [10.0, 16.0 + 24.0 * i as f32, 100.0, 20.0])
            .chain([[10.0, 200.0, 50.0, 20.0]])
            .collect();
-        assert_eq!(scroll_shift(&before, &after), Some(-24.0));
-        assert_eq!(scroll_shift(&before, &before), None);
+        assert_eq!(scroll_shift(&before, &after, true), Some(-24.0));
+        // Rows this far apart line up the other way too; the direction is what tells them apart.
+        assert_eq!(scroll_shift(&before, &after, false), Some(24.0));
+        assert_eq!(scroll_shift(&before, &before, true), None);
        let tabs = [
            ([60.0, 0.0, 26.0, 32.0], false),
            ([0.0, 0.0, 26.0, 32.0], true),
@@ -1624,6 +2165,127 @@ mod tests {
        assert!(steam_keyboard(TextKeyboard::Steam) && !steam_keyboard(TextKeyboard::Horizon));
    }

+    #[test]
+    fn a_list_step_scrolls_rather_than_leave_a_list_that_can() {
+        let rows = |n: usize| -> Vec<Rect> {
+            (0..n)
+                .map(|i| [100.0, 40.0 + i as f32 * 36.0, 270.0, 36.0])
+                .collect()
+        };
+        let back: Rect = [150.0, 220.0, 150.0, 20.0];
+        let search: Rect = [150.0, 10.0, 150.0, 20.0];
+        let mut targets = rows(4);
+        targets.extend([back, search]);
+        let area = |up, down| ScrollArea {
+            rect: [0.0, 40.0, 380.0, 144.0],
+            amount: 0.0,
+            up,
+            down,
+        };
+        let (down, up) = (Button::DPadDown, Button::DPadUp);
+        let step = |from, button, area: &[ScrollArea]| list_step(from, button, &targets, area);
+        // A row below in view comes first.
+        assert_eq!(step(targets[1], down, &[area(true, true)]), Some(2));
+        // The last row in view: more below scrolls; none leaves.
+        assert_eq!(step(targets[3], down, &[area(true, true)]), None);
+        assert_eq!(step(targets[3], down, &[area(true, false)]), Some(4));
+        // The first row in view, the same upwards.
+        assert_eq!(step(targets[0], up, &[area(true, false)]), None);
+        assert_eq!(step(targets[0], up, &[area(false, true)]), Some(5));
+        // From outside the list it enters it, and no list means a plain step.
+        assert_eq!(step(back, up, &[area(true, true)]), Some(3));
+        assert_eq!(step(targets[3], down, &[]), Some(4));
+    }
+
+    #[test]
+    fn a_list_step_shows_its_row_whole_and_starts_from_one_nearly_gone() {
+        let area = |up, down| ScrollArea {
+            rect: [0.0, 40.0, 380.0, 100.0],
+            amount: 50.0,
+            up,
+            down,
+        };
+        let (down, up) = (Button::DPadDown, Button::DPadUp);
+        // The next row is cut by the view's bottom: it scrolls first, unless that's the end.
+        let targets: Vec<Rect> = vec![[100.0, 100.0, 270.0, 25.0], [100.0, 125.0, 270.0, 25.0]];
+        assert_eq!(
+            list_step(targets[0], down, &targets, &[area(true, true)]),
+            None
+        );
+        assert_eq!(
+            list_step(targets[0], down, &targets, &[area(true, false)]),
+            Some(1)
+        );
+        // The same at its top.
+        let targets: Vec<Rect> = vec![[100.0, 30.0, 270.0, 25.0], [100.0, 55.0, 270.0, 25.0]];
+        assert_eq!(
+            list_step(targets[1], up, &targets, &[area(true, true)]),
+            None
+        );
+        // A focused row with its last pixels in view is still in the list: going up scrolls,
+        // even with something above the list to go to.
+        let row: Rect = [100.0, 18.0, 270.0, 25.0];
+        let field: Rect = [150.0, 0.0, 150.0, 15.0];
+        assert!(area(true, true).holds(&row));
+        assert_eq!(list_step(row, up, &[row, field], &[area(true, true)]), None);
+        // Above the view altogether, it isn't.
+        assert!(!area(true, true).holds(&[100.0, 10.0, 270.0, 25.0]));
+    }
+
+    #[test]
+    fn a_stick_holds_its_direction_until_it_lets_go_or_turns() {
+        let step = 0.55;
+        let (up, right) = (Some(Button::DPadUp), Some(Button::DPadRight));
+        // Only a push past the threshold starts a step.
+        assert_eq!(stick_direction_held([0.0, 0.5], step, None), None);
+        assert_eq!(stick_direction_held([0.0, 0.6], step, None), up);
+        // Wobbling on the threshold keeps it; falling back past the release lets go.
+        assert_eq!(stick_direction_held([0.0, 0.5], step, up), up);
+        assert_eq!(stick_direction_held([0.0, 0.3], step, up), None);
+        // A diagonal doesn't flip it, but a clear turn does.
+        assert_eq!(stick_direction_held([0.6, 0.55], step, up), up);
+        assert_eq!(stick_direction_held([0.55, 0.6], step, right), right);
+        assert_eq!(stick_direction_held([0.9, 0.3], step, up), right);
+        // Straight across to the other side.
+        assert_eq!(
+            stick_direction_held([0.0, -0.9], step, up),
+            Some(Button::DPadDown)
+        );
+        // Past the release on the far side, but not far enough for a step.
+        assert_eq!(stick_direction_held([0.0, -0.45], step, up), None);
+    }
+
+    #[test]
+    fn a_repeat_stops_where_the_slots_end() {
+        let at = (100.0, 100.0);
+        assert!(!repeat_crosses_slots(at, (118.0, 100.0), true));
+        // The hotbar, over its small gap, is the same run of slots.
+        assert!(!repeat_crosses_slots(at, (100.0, 122.0), true));
+        // Another block of slots, or a button.
+        assert!(repeat_crosses_slots(at, (100.0, 132.0), true));
+        assert!(repeat_crosses_slots(at, (118.0, 100.0), false));
+    }
+
+    #[test]
+    fn a_resize_keeps_the_same_widget() {
+        let before: Vec<Rect> = vec![[10.0, 10.0, 20.0, 20.0], [100.0, 10.0, 20.0, 20.0]];
+        let after: Vec<Rect> = vec![[300.0, 90.0, 20.0, 20.0], [400.0, 90.0, 20.0, 20.0]];
+        let (old, new) = ((200.0, 100.0), (800.0, 400.0));
+        // The same count: the same place in the draw order, however far it moved.
+        assert_eq!(
+            refind_resized(before[0], &before, &after, old, new),
+            Some(0)
+        );
+        // A list showing more rows: the nearest to where it would be.
+        let more: Vec<Rect> = vec![
+            [30.0, 30.0, 20.0, 20.0],
+            [395.0, 35.0, 20.0, 20.0],
+            [700.0, 300.0, 20.0, 20.0],
+        ];
+        assert_eq!(refind_resized(before[1], &before, &more, old, new), Some(1));
+        assert_eq!(refind_resized(before[0], &before, &[], old, new), None);
+    }
+
    #[test]
    fn labels_and_conflicts() {
        assert_eq!(Button::South.label(GlyphStyle::Xbox), "A");
@@ -1787,12 +2449,27 @@ mod tests {
    }

    #[test]
-    fn hotbar_wraps_and_glyphs_follow_the_vendor() {
-        assert_eq!(hotbar_step(8, true), 0);
-        assert_eq!(hotbar_step(0, false), 8);
-        assert_eq!(hotbar_step(3, true), 4);
-        assert_eq!(GlyphStyle::of_vendor(Some(0x054c)), GlyphStyle::PlayStation);
-        assert_eq!(GlyphStyle::of_vendor(Some(0x28de)), GlyphStyle::Xbox);
-        assert_eq!(GlyphStyle::of_vendor(None), GlyphStyle::Xbox);
+    fn glyphs_follow_the_vendor() {
+        let of = |vendor, product| GlyphStyle::of_device(Some(vendor), Some(product));
+        // Any product of the consoles' makers.
+        assert_eq!(of(0x054c, 0x0ce6), GlyphStyle::PlayStation);
+        assert_eq!(of(0x054c, 0x0001), GlyphStyle::PlayStation);
+        assert_eq!(of(0x057e, 0x2009), GlyphStyle::Nintendo);
+        // A pad made for a console by another maker, and that maker's others.
+        assert_eq!(of(0x0f0d, 0x0066), GlyphStyle::PlayStation);
+        assert_eq!(of(0x0f0d, 0x00c1), GlyphStyle::Nintendo);
+        assert_eq!(of(0x0f0d, 0x0067), GlyphStyle::Xbox);
+        assert_eq!(of(0x20d6, 0xa711), GlyphStyle::Nintendo);
+        // Valve's virtual pad, Microsoft's, nothing known, nothing reported.
+        assert_eq!(of(0x28de, 0x11ff), GlyphStyle::Xbox);
+        assert_eq!(of(0x045e, 0x0b12), GlyphStyle::Xbox);
+        assert_eq!(of(0x1234, 0x5678), GlyphStyle::Xbox);
+        assert_eq!(GlyphStyle::of_device(None, None), GlyphStyle::Xbox);
+        // A vendor alone is enough only for the consoles' makers.
+        assert_eq!(
+            GlyphStyle::of_device(Some(0x054c), None),
+            GlyphStyle::PlayStation
+        );
+        assert_eq!(GlyphStyle::of_device(Some(0x0f0d), None), GlyphStyle::Xbox);
    }
 }
@@ -3,15 +3,18 @@
 //! device letting go (splitscreen moving the keyboard to another player, say)
 //! can't release what another still presses.

+use crate::actions::Action;
 use std::collections::HashMap;
 use winit::keyboard::KeyCode;

 /// Where a press came from.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Source {
-    /// The keyboard and mouse, and the scripting socket acting as them.
+    /// The keyboard and mouse.
    Keyboard,
    Pad,
+    /// `horizon-ctl`'s `key` and `mouse` and the agent commands that walk and click.
+    Agent,
 }

 impl Source {
@@ -19,6 +22,7 @@ impl Source {
        match self {
            Source::Keyboard => 1,
            Source::Pad => 2,
+            Source::Agent => 4,
        }
    }
 }
@@ -29,9 +33,20 @@ pub struct HeldKeys {
 }

 impl HeldKeys {
-    pub fn contains(&self, key: &KeyCode) -> bool {
+    /// Whether anything holds this mapping: every device, whatever the mapping is bound to.
+    pub fn held(&self, action: Action) -> bool {
+        action.key().is_some_and(|key| self.raw(&key))
+    }
+    /// Whether a key that is no mapping's default is held (Right Shift, the arrows, Alt, the system
+    /// key), or the key a caller already holds as a key: most code wants [`HeldKeys::held`].
+    pub fn raw(&self, key: &KeyCode) -> bool {
        self.held.contains_key(key)
    }
+    /// The old way of asking, by a mapping's default key; clippy refuses it (`clippy.toml`). It
+    /// stays so that a change written against it says what to use instead.
+    pub fn contains(&self, key: &KeyCode) -> bool {
+        self.raw(key)
+    }
    /// `source` holds `key`. True when nothing held it before.
    pub fn press(&mut self, key: KeyCode, source: Source) -> bool {
        let sources = self.held.entry(key).or_insert(0);
@@ -72,7 +87,7 @@ impl HeldKeys {
    /// Held, by the keyboard unless a device already holds it: for callers
    /// that don't say where the press came from.
    pub fn insert(&mut self, key: KeyCode) -> bool {
-        if self.contains(&key) {
+        if self.raw(&key) {
            return false;
        }
        self.press(key, Source::Keyboard)
@@ -132,13 +147,25 @@ mod tests {
        assert!(!keys.press(KeyCode::Space, Source::Keyboard));
        assert!(keys.press(KeyCode::KeyW, Source::Keyboard));
        assert_eq!(keys.release_source(Source::Keyboard), vec![KeyCode::KeyW]);
-        assert!(keys.contains(&KeyCode::Space) && !keys.contains(&KeyCode::KeyW));
+        assert!(keys.held(Action::Jump) && !keys.held(Action::Forward));
        assert!(keys.held_by(&KeyCode::Space, Source::Pad));
        assert!(!keys.held_by(&KeyCode::Space, Source::Keyboard));
        assert!(keys.release(&KeyCode::Space, Source::Pad));
        assert!(keys.is_empty());
    }

+    #[test]
+    fn a_script_holds_a_key_by_itself() {
+        let mut keys = HeldKeys::default();
+        keys.press(KeyCode::KeyW, Source::Agent);
+        keys.press(KeyCode::KeyW, Source::Keyboard);
+        assert!(!keys.release(&KeyCode::KeyW, Source::Keyboard));
+        assert!(keys.held(Action::Forward));
+        assert!(keys.release_source(Source::Pad).is_empty());
+        assert_eq!(keys.release_source(Source::Agent), vec![KeyCode::KeyW]);
+        assert!(!keys.held(Action::Forward));
+    }
+
    #[test]
    fn untagged_inserts_and_removes_act_as_before() {
        let mut keys = HeldKeys::default();
@@ -149,7 +176,7 @@ mod tests {
            keys.remove(&KeyCode::ShiftLeft),
            "remove lets go for everyone"
        );
-        assert!(!keys.contains(&KeyCode::ShiftLeft));
+        assert!(!keys.held(Action::Sneak));
        assert!(keys.release(&KeyCode::KeyA, Source::Keyboard), "never held");
    }
 }
@@ -51,11 +51,6 @@ impl InteractionInput {
    pub fn press(&mut self, button: Button) {
        self.clicks[button as usize] += 1;
    }
-    /// Whether a click waits for the next tick.
-    pub fn has_clicks(&self) -> bool {
-        self.clicks.iter().any(|&c| c > 0)
-    }
-
    pub fn tick(&mut self, world: &mut impl InteractionWorld, attack_down: bool, use_down: bool) {
        let [attack, use_item, pick] = std::mem::take(&mut self.clicks);
        world.pick_hit_result();
@@ -74,6 +74,17 @@ pub const MAPPINGS: &[(&str, &str, &str)] = &[
    ("key.debug.lightmapTexture", "key.keyboard.4", "debug"),
    ("key.debug.improvedTransparency", "key.keyboard.x", "debug"),
 ];
+/// Horizon's own key mappings: bound in Controls like the vanilla ones, but kept in
+/// `horizon-extras.txt` (`emoteKey`), never in `options.txt`, which stays exactly vanilla's
+/// (`MAPPINGS` is what the options parity harness compares with the pinned client).
+pub const HORIZON_MAPPINGS: &[(&str, &str, &str)] = &[
+    // The emote wheel (docs/cosmetics.md), on a key vanilla leaves free.
+    ("key.emote", "key.keyboard.b", "multiplayer"),
+];
+/// Every mapping the game binds: vanilla's in `Options.keyMappings` order, then Horizon's.
+pub fn all_mappings() -> impl Iterator<Item = &'static (&'static str, &'static str, &'static str)> {
+    MAPPINGS.iter().chain(HORIZON_MAPPINGS)
+}
 /// Mappings Options builds as `ToggleKeyMapping` (hold or toggle by option).
 pub fn is_toggle(name: &str) -> bool {
    matches!(name, "key.sneak" | "key.sprint" | "key.use" | "key.attack")
@@ -312,8 +323,7 @@ pub struct KeyBinds {
 impl Default for KeyBinds {
    fn default() -> Self {
        Self {
-            keys: MAPPINGS
-                .iter()
+            keys: all_mappings()
                .map(|(n, d, _)| (*n, (*d).to_owned()))
                .collect(),
        }
@@ -339,8 +349,7 @@ impl KeyBinds {
            .map_or("key.keyboard.unknown", String::as_str)
    }
    pub fn default_of(name: &str) -> &'static str {
-        MAPPINGS
-            .iter()
+        all_mappings()
            .find(|m| m.0 == name)
            .map_or("key.keyboard.unknown", |m| m.1)
    }
@@ -348,16 +357,24 @@ impl KeyBinds {
        self.get(name) == Self::default_of(name)
    }
    pub fn set(&mut self, name: &str, key: &str) {
-        if let Some((n, _, _)) = MAPPINGS.iter().find(|m| m.0 == name) {
+        if let Some((n, _, _)) = all_mappings().find(|m| m.0 == name) {
            self.keys.insert(n, key.to_owned());
        }
    }
+    /// The bindings `options.txt` holds: vanilla's mappings only.
    pub fn saved(&self) -> Vec<(&'static str, String)> {
        MAPPINGS
            .iter()
            .map(|(n, _, _)| (*n, self.get(n).to_owned()))
            .collect()
    }
+    /// Horizon's own bindings, for `horizon-extras.txt`.
+    pub fn horizon_saved(&self) -> Vec<(&'static str, String)> {
+        HORIZON_MAPPINGS
+            .iter()
+            .map(|(n, _, _)| (*n, self.get(n).to_owned()))
+            .collect()
+    }
    pub fn reset_all(&mut self) {
        *self = Self::default();
    }
@@ -367,8 +384,7 @@ impl KeyBinds {
        if key == "key.keyboard.unknown" {
            return Vec::new();
        }
-        MAPPINGS
-            .iter()
+        all_mappings()
            .filter(|(n, _, _)| {
                *n != name && self.get(n) == key && (!self.is_default(n) || !self.is_default(name))
            })
@@ -382,8 +398,7 @@ impl KeyBinds {
    /// Every mapping a physical input triggers, in list order: like
    /// `KeyMapping.set`/`click`, one key drives all the mappings bound to it.
    pub fn mappings_for<'a>(&'a self, key: &'a str) -> impl Iterator<Item = &'static str> + 'a {
-        MAPPINGS
-            .iter()
+        all_mappings()
            .map(|m| m.0)
            .filter(move |n| self.get(n) == key)
    }
@@ -393,8 +408,7 @@ impl KeyBinds {
    /// key and the binding itself); their defaults (A, S, D, T, L, 1 to 4...)
    /// would otherwise turn the key back into its old gameplay meaning.
    fn translated_mappings<'a>(&'a self, key: &'a str) -> impl Iterator<Item = &'static str> + 'a {
-        MAPPINGS
-            .iter()
+        all_mappings()
            .filter(|m| m.2 != "debug")
            .map(|m| m.0)
            .filter(move |n| self.get(n) == key)
@@ -402,9 +416,7 @@ impl KeyBinds {
    /// Whether a mapping (other than a debug key) whose default is `key` was
    /// bound elsewhere.
    fn default_moved(&self, key: &str) -> bool {
-        MAPPINGS
-            .iter()
-            .any(|(n, d, c)| *d == key && *c != "debug" && !self.is_default(n))
+        all_mappings().any(|(n, d, c)| *d == key && *c != "debug" && !self.is_default(n))
    }
    /// Translate a physical key into the default key of the mapping it is
    /// bound to, so game code written against vanilla defaults follows the
@@ -440,6 +452,18 @@ impl KeyBinds {
        }
        vec![Ok(key)]
    }
+    /// `Minecraft.handleKeybinds`: key.pickItem and key.spectatorHotbar share the middle button by
+    /// default and are separate mappings, so a press of what `input` is bound to acts only as the
+    /// one this player can use: the spectator hotbar for a spectator, pick block otherwise. (Pick
+    /// block does nothing a spectator would see.)
+    pub fn middle_acts(&self, input: &str, spectator: bool) -> bool {
+        let mapping = if spectator {
+            "key.spectatorHotbar"
+        } else {
+            "key.pickItem"
+        };
+        self.get(mapping) == input
+    }
    /// Translate a mouse button the same way (keys bound to mouse buttons).
    pub fn translate_mouse(&self, button: MouseButton) -> Option<Result<KeyCode, MouseButton>> {
        self.translate_mouse_all(button).into_iter().next()
@@ -503,6 +527,27 @@ impl KeyBinds {
 #[cfg(test)]
 mod tests {
    use super::*;
+
+    #[test]
+    fn mappings_sharing_the_middle_button_act_as_themselves() {
+        let middle = "key.mouse.middle";
+        let z = "key.keyboard.z";
+        let mut keys = KeyBinds::default();
+        assert!(keys.middle_acts(middle, false) && keys.middle_acts(middle, true));
+        // The spectator hotbar on Z: the middle button only picks, and Z never picks.
+        keys.set("key.spectatorHotbar", z);
+        assert!(keys.middle_acts(middle, false));
+        assert!(!keys.middle_acts(middle, true));
+        assert!(keys.middle_acts(z, true));
+        assert!(!keys.middle_acts(z, false));
+        // Pick block on Z instead: the other way round.
+        keys.reset_all();
+        keys.set("key.pickItem", z);
+        assert!(keys.middle_acts(z, false));
+        assert!(!keys.middle_acts(z, true));
+        assert!(keys.middle_acts(middle, true));
+        assert!(!keys.middle_acts(middle, false));
+    }
    #[test]
    fn container_mouse_hotkeys_follow_slot_bindings_and_pick_item_priority() {
        for button in [MouseButton::Back, MouseButton::Forward, MouseButton::Middle] {
@@ -3,6 +3,7 @@
 //! options. horizon-client re-exports each module under its old path
 //! (`horizon_client::keybinds`, ...).
 #![forbid(unsafe_code)]
+pub mod actions;
 pub mod clipboard;
 pub mod gamepad;
 pub mod held;
@@ -91,6 +91,36 @@ pub fn settle(start: Point, end: Point, targets: &[Point], tuning: &Tuning) -> O
    }
 }

+/// Where a cursor left on a target goes once the targets moved: with most of
+/// them if they moved together (a recipe book opened), else to the nearest
+/// one (a creative tab with other slots), so it never rests between targets.
+/// `None` when it wasn't on a target, or one is still there.
+pub fn follow(at: Point, before: &[Point], after: &[Point]) -> Option<usize> {
+    const SAME: f32 = 0.5;
+    let on = before.iter().find(|t| distance(at, **t) <= SAME)?;
+    if after.iter().any(|t| distance(at, *t) <= SAME) {
+        return None;
+    }
+    let carried = |by: Point| {
+        before
+            .iter()
+            .filter(|b| {
+                let moved = (b.0 + by.0, b.1 + by.1);
+                after.iter().any(|a| distance(moved, *a) <= SAME)
+            })
+            .count()
+    };
+    let together = after
+        .iter()
+        .enumerate()
+        .map(|(i, a)| (i, carried((a.0 - on.0, a.1 - on.1))))
+        .max_by_key(|&(_, count)| count)
+        .filter(|&(_, count)| count * 2 > before.len());
+    together
+        .map(|(i, _)| i)
+        .or_else(|| nearest(at, after, f32::INFINITY))
+}
+
 /// The cursor `seconds` into a glide from `from` to `to`: eased out, so it
 /// slows as it lands, and exactly `to` once the glide is over.
 pub fn glide(from: Point, to: Point, seconds: f32, tuning: &Tuning) -> Point {
@@ -109,6 +139,26 @@ mod tests {
    /// A row of inventory slots, 18 pixels apart, and the slot below the first.
    const SLOTS: [Point; 4] = [(8.0, 8.0), (26.0, 8.0), (44.0, 8.0), (8.0, 26.0)];

+    #[test]
+    fn follow_goes_with_targets_that_moved_together() {
+        let moved = SLOTS.map(|s| (s.0 + 77.0, s.1));
+        assert_eq!(follow(SLOTS[1], &SLOTS, &moved), Some(1));
+    }
+
+    #[test]
+    fn follow_takes_the_nearest_of_other_targets() {
+        let other = [(30.0, 50.0), (200.0, 200.0)];
+        assert_eq!(follow(SLOTS[1], &SLOTS, &other), Some(0));
+    }
+
+    #[test]
+    fn follow_leaves_a_free_cursor_and_a_target_still_there() {
+        let other = [(30.0, 50.0)];
+        assert_eq!(follow((100.0, 100.0), &SLOTS, &other), None);
+        assert_eq!(follow(SLOTS[0], &SLOTS, &SLOTS), None);
+        assert_eq!(follow(SLOTS[0], &SLOTS, &[]), None);
+    }
+
    #[test]
    fn a_short_flick_moves_to_the_neighbour_it_heads_for() {
        // 4 pixels right of slot 0: still nearest slot 0, but heading for slot 1.
@@ -393,19 +393,38 @@ impl FullscreenState {
        let reapply = self.set_exclusive(exclusive);
        self.set_preferred_mode(preferred);
        let mode_change = !in_video_screen && self.take_mode_change();
-        match request {
-            Some(false) => window.set_fullscreen(None),
-            Some(true) => window.set_fullscreen(Some(fullscreen_request(
+        if wanted && window.is_maximized() {
+            window.set_maximized(false);
+            window.set_fullscreen(Some(fullscreen_request(
                window,
                exclusive,
                preferred.as_ref(),
-            ))),
-            None if reapply || mode_change => window.set_fullscreen(Some(fullscreen_request(
-                window,
-                exclusive,
-                preferred.as_ref(),
-            ))),
-            None => {}
+            )));
+        } else {
+            match request {
+                Some(false) => window.set_fullscreen(None),
+                Some(true) => {
+                    if window.is_maximized() {
+                        window.set_maximized(false);
+                    }
+                    window.set_fullscreen(Some(fullscreen_request(
+                        window,
+                        exclusive,
+                        preferred.as_ref(),
+                    )));
+                }
+                None if reapply || mode_change => {
+                    if window.is_maximized() {
+                        window.set_maximized(false);
+                    }
+                    window.set_fullscreen(Some(fullscreen_request(
+                        window,
+                        exclusive,
+                        preferred.as_ref(),
+                    )));
+                }
+                None => {}
+            }
        }
    }

@@ -592,13 +611,13 @@ pub fn fullscreen_request(
    preferred: Option<&VideoMode>,
 ) -> winit::window::Fullscreen {
    use winit::window::Fullscreen;
-    if !exclusive {
-        return Fullscreen::Borderless(None);
-    }
-    let Some(monitor) = window
+    let monitor = window
        .current_monitor()
-        .or_else(|| window.primary_monitor())
-    else {
+        .or_else(|| window.primary_monitor());
+    if !exclusive {
+        return Fullscreen::Borderless(monitor);
+    }
+    let Some(monitor) = monitor else {
        return Fullscreen::Borderless(None);
    };
    let wanted = preferred.and_then(|p| {
@@ -608,7 +627,7 @@ pub fn fullscreen_request(
    });
    match wanted.or_else(|| monitor_current_mode(&monitor)) {
        Some(mode) => Fullscreen::Exclusive(mode),
-        None => Fullscreen::Borderless(None),
+        None => Fullscreen::Borderless(Some(monitor)),
    }
 }

@@ -628,6 +647,22 @@ pub fn icon() -> Option<winit::window::Icon> {
    winit::window::Icon::from_rgba(bytes, info.width, info.height).ok()
 }

+/// Apply Horizon's icon to every window. Windows has a separate taskbar icon slot from the small
+/// window icon; requiring the decoded icon there prevents a generic taskbar icon from appearing.
+pub fn with_horizon_icon(
+    attributes: winit::window::WindowAttributes,
+) -> winit::window::WindowAttributes {
+    let icon = icon();
+    #[cfg(target_os = "windows")]
+    let icon = Some(icon.expect("Horizon's icon must be available on Windows"));
+
+    let attributes = attributes.with_window_icon(icon.clone());
+    #[cfg(target_os = "windows")]
+    let attributes =
+        winit::platform::windows::WindowAttributesExtWindows::with_taskbar_icon(attributes, icon);
+    attributes
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -18,6 +18,8 @@ horizon-client-core = { path = "../horizon-client-core" }
 horizon-client-input = { path = "../horizon-client-input" }
 horizon-client-render = { path = "../horizon-client-render" }
 horizon-command = { path = "../horizon-command" }
+# Emotes pose the player model (`Mob::emote`, `mobs::anim::setup`).
+horizon-cosmetics = { path = "../horizon-cosmetics" }
 horizon-items = { path = "../horizon-items" }
 horizon-core = { path = "../horizon-core" }
 # `horizon-ctl mcp`: the Model Context Protocol, shared with the launcher and the server.
@@ -30,6 +32,8 @@ horizon-world = { path = "../horizon-world" }
 horizon-protocol = { path = "../horizon-protocol" }
 # server.properties, eula.txt and the user lists, shared with horizon-server.
 horizon-server-files = { path = "../horizon-server-files" }
+# The control endpoint's token (control.rs), as horizon-server's and the relay's.
+getrandom = "0.3"
 # The dedicated server's anticheat, off unless server.toml's [anticheat] turns it on (docs/anticheat.md).
 horizon-anticheat = { path = "../horizon-anticheat" }
 # The dedicated server's chat filter: [chat_filter], the slur list, mutes (docs/chat-filter.md).
@@ -648,6 +648,7 @@ fn remesh(
                        nether_shading: false,
                        shader_pack_lighting: false,
                        separate_ao: false,
+                        shader_pack: false,
                        assets,
                        render,
                        tables: &tables,
@@ -355,6 +355,7 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        outline: Vec::new(),
        outline_after_terrain: false,
        outline_high_contrast: false,
+        pvp: Default::default(),
        debug_lines: &[],
        debug_lines_on_top: &[],
        debug_crosshair: &[],
@@ -377,6 +378,7 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        lightning: Default::default(),
        additive: &[],
        see_through: &[],
+        world_primitives: Default::default(),
        shadow_only: &[],
        celestial: &[],
        stars: None,
@@ -6,13 +6,7 @@ use horizon_world::{
    worldgen::{tags::TagDefinitions, terrain::TerrainBlockStates},
 };
 use serde_json::Value;
-use std::{
-    collections::BTreeSet,
-    fs::File,
-    io::{self, BufReader},
-    path::Path,
-    sync::Arc,
-};
+use std::{collections::BTreeSet, io, path::Path, sync::Arc};

 pub const MATERIALS: [&str; 6] = ["bedrock", "dirt", "stone", "sand", "oak_planks", "bricks"];
 #[derive(Clone, Copy)]
@@ -190,15 +184,12 @@ fn invalid(message: &str) -> io::Error {
 }
 impl Assets {
    pub fn load(root: &Path) -> Result<Self> {
-        let manifest: Value = serde_json::from_reader(BufReader::new(File::open(
-            root.join("horizon-resources.json"),
-        )?))?;
+        let manifest: Value = horizon_world::json_file::read(&root.join("horizon-resources.json"))?;
        if manifest["data_version"].as_i64() != Some(i64::from(DATA_VERSION)) {
            return Err(invalid("resources do not match Horizon's pinned data version").into());
        }
        let (registry, flags) = horizon_world::level::data::load_registry_with_flags(root)?;
-        let bundle: Value =
-            serde_json::from_reader(BufReader::new(File::open(root.join("block-tags.json"))?))?;
+        let bundle: Value = horizon_world::json_file::read(&root.join("block-tags.json"))?;
        let mut definitions = TagDefinitions::default();
        for (name, text) in bundle
            .as_object()
@@ -352,6 +343,7 @@ impl RenderAssets {
        }
        for stage in 0..10 {
            sprites.insert(root, &format!("minecraft:block/destroy_stage_{stage}"))?;
+            sprites.insert(root, &format!("minecraft:block/destroy_oit_stage_{stage}"))?;
        }
        let fusion = if draws {
            let _step = crate::spans::startup::step("core.fusion");
@@ -2,7 +2,9 @@
 //! small mixer standing in for OpenAL: one channel per source with its gain,
 //! pitch, linear distance attenuation (`AL_LINEAR_DISTANCE`, reference 0,
 //! rolloff 1), looping, relative flag and source state, Ogg/Vorbis decoding
-//! (streams on a worker thread) and OpenAL Soft's stereo panning.
+//! (streams on a worker thread) and OpenAL Soft's mixing: mono sources panned
+//! and attenuated, multi-channel buffers (stereo music and records) played
+//! direct as OpenAL does.
 use crate::Result;
 use crate::sound_engine::{
    Attenuation, Backend, Bound, ChannelId, InstanceId, PlayResult, SoundEngine, SoundInstance,
@@ -29,7 +31,7 @@ enum State {
 }
 /// An OpenAL source.
 struct Channel {
-    samples: Option<(Arc<Vec<f32>>, u32)>,
+    samples: Option<(Arc<Vec<f32>>, u32, u16)>,
    position: f64,
    state: State,
    gain: f32,
@@ -135,8 +137,8 @@ impl Drop for MixerBackend {
 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 interleaved samples, their rate and channel count (`None`: the file did not load).
+type Samples = Option<(Arc<Vec<f32>>, u32, u16)>;
 /// Decoded static sounds (`SoundBufferLibrary`'s buffers), dropped least
 /// recently used first past `CACHE_BYTES`: kept forever, every sound heard in
 /// a session stayed (up to 1.4 GiB of samples, villages playing hundreds).
@@ -177,7 +179,7 @@ impl SoundCache {
    fn size(samples: &Samples) -> usize {
        samples
            .as_ref()
-            .map_or(0, |(s, _)| s.len() * std::mem::size_of::<f32>())
+            .map_or(0, |(s, _, _)| s.len() * std::mem::size_of::<f32>())
    }
 }
 /// A static sound to decode for a channel waiting on it.
@@ -208,6 +210,18 @@ fn attach(mixer: &Mutex<Mixer>, channel: ChannelId, samples: Samples, looping: b
 type Stream = cpal::Stream;
 #[cfg(not(feature = "audio"))]
 type Stream = std::convert::Infallible;
+/// A level sound retained for the network broadcaster, in playback order.
+#[derive(Clone, Debug)]
+pub struct CapturedSound {
+    pub event: String,
+    pub position: [f64; 3],
+    pub volume: f32,
+    pub pitch: f32,
+    pub source: usize,
+    pub entity: Option<u32>,
+    pub except_entity: Option<u32>,
+}
+
 pub struct Audio {
    _stream: Option<Stream>,
    device_name: String,
@@ -224,7 +238,7 @@ pub struct Audio {
    source_override: Option<usize>,
    /// Positional sounds played since the last drain, kept while the world
    /// is open to the network so guests hear them too.
-    pub capture: Option<Vec<(String, [f64; 3], f32, f32)>>,
+    pub capture: Option<Vec<CapturedSound>>,
    /// How many times each positional sound played (the control socket's `status`),
    /// with or without an audio device.
    pub heard: std::collections::BTreeMap<String, u32>,
@@ -248,7 +262,7 @@ pub struct Audio {
    #[cfg(feature = "audio")]
    device_ticks: u32,
 }
-fn decode(path: &Path) -> Option<(Vec<f32>, u32)> {
+fn decode(path: &Path) -> Option<(Vec<f32>, u32, u16)> {
    use symphonia::core::{
        audio::SampleBuffer, codecs::DecoderOptions, formats::FormatOptions, io::MediaSourceStream,
        meta::MetadataOptions, probe::Hint,
@@ -272,7 +286,8 @@ fn decode(path: &Path) -> Option<(Vec<f32>, u32)> {
    let mut decoder = symphonia::default::get_codecs()
        .make(&track.codec_params, &DecoderOptions::default())
        .ok()?;
-    let mut mono = Vec::new();
+    let mut samples = Vec::new();
+    let mut channels = 0u16;
    while let Ok(packet) = format.next_packet() {
        if packet.track_id() != id {
            continue;
@@ -281,14 +296,34 @@ fn decode(path: &Path) -> Option<(Vec<f32>, u32)> {
            continue;
        };
        let spec = *buffer.spec();
-        let channels = spec.channels.count().max(1);
-        let mut samples = SampleBuffer::<f32>::new(buffer.capacity() as u64, spec);
-        samples.copy_interleaved_ref(buffer);
-        for frame in samples.samples().chunks(channels) {
-            mono.push(frame.iter().sum::<f32>() / channels as f32);
+        let frame_channels = spec.channels.count().max(1);
+        let mut decoded = SampleBuffer::<f32>::new(buffer.capacity() as u64, spec);
+        decoded.copy_interleaved_ref(buffer);
+        if channels == 0 {
+            channels = frame_channels.min(2) as u16;
+        }
+        if frame_channels <= 2 {
+            samples.extend_from_slice(decoded.samples());
+        } else {
+            // OpenAL plays multi-channel buffers direct; a stereo output hears the odd/even split.
+            for frame in decoded.samples().chunks(frame_channels) {
+                let (mut left, mut right) = (0.0, 0.0);
+                let (mut lefts, mut rights) = (0.0f32, 0.0f32);
+                for (i, sample) in frame.iter().enumerate() {
+                    if i % 2 == 0 {
+                        left += sample;
+                        lefts += 1.0;
+                    } else {
+                        right += sample;
+                        rights += 1.0;
+                    }
+                }
+                samples.push(left / lefts.max(1.0));
+                samples.push(right / rights.max(1.0));
+            }
        }
    }
-    Some((mono, rate))
+    (channels != 0).then_some((samples, rate, channels))
 }
 /// 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.
@@ -415,7 +450,7 @@ impl Backend for MixerBackend {
            // A streamed sound loops by restarting its stream.
            let mixer = self.mixer.clone();
            std::thread::spawn(move || {
-                let samples = decode(&file).map(|(s, r)| (Arc::new(s), r));
+                let samples = decode(&file).map(|(s, r, c)| (Arc::new(s), r, c));
                attach(&mixer, channel, samples, looping);
            });
            return;
@@ -436,7 +471,7 @@ impl Backend for MixerBackend {
                        // Queued twice before the first decode finished.
                        let cached = cache.lock().ok().and_then(|mut c| c.get(&job.key));
                        let samples = cached.unwrap_or_else(|| {
-                            let samples = decode(&job.file).map(|(s, r)| (Arc::new(s), r));
+                            let samples = decode(&job.file).map(|(s, r, c)| (Arc::new(s), r, c));
                            if let Ok(mut c) = cache.lock() {
                                c.insert(job.key, samples.clone());
                            }
@@ -572,9 +607,13 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
    let mut voices = std::mem::take(&mut mixer.voices);
    voices.clear();
    for (id, c) in &mixer.channels {
-        let Some((_, source_rate)) = &c.samples else {
+        let Some((_, source_rate, source_channels)) = &c.samples else {
            continue;
        };
+        // OpenAL plays a multi-channel buffer direct: no panning and no distance attenuation
+        // (`CalcVoiceParams`' non-spatialized path, vanilla's HRTF-off stereo context). Vanilla's
+        // music and records are stereo. A mono buffer is the positional one.
+        let direct = *source_channels > 1;
        if c.state != State::Playing {
            continue;
        }
@@ -599,24 +638,33 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
        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 = if camera.is_some() {
-            c.gain.clamp(0.0, 1.0) * distance_gain(c.linear, distance)
+            c.gain.clamp(0.0, 1.0)
+                * if direct {
+                    1.0
+                } else {
+                    distance_gain(c.linear, distance)
+                }
        } else {
            0.0
        };
-        // Relative sources are already in OpenAL's listener space (-Z ahead).
-        let [mut left, mut right] = if c.relative {
-            stereo_gains(d[0] as f32, d[1] as f32, -d[2] as f32)
+        let [left, right] = if direct {
+            [gain, gain]
        } else {
-            stereo_gains(dot(d, right), dot(d, up), dot(d, forward))
+            // Relative sources are already in OpenAL's listener space (-Z ahead).
+            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;
+            }
+            [left * gain, right * gain]
        };
-        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;
-        }
-        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));
    }
@@ -624,13 +672,15 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
        let Some(c) = mixer.channels.get_mut(&id) else {
            continue;
        };
-        let Some((samples, _)) = c.samples.clone() else {
+        let Some((samples, _, source_channels)) = c.samples.clone() else {
            continue;
        };
+        let source_channels = source_channels as usize;
+        let frames = samples.len() / source_channels;
        for frame in data.chunks_mut(channels) {
            let mut i = c.position as usize;
-            if i + 1 >= samples.len() {
-                if c.looping && samples.len() > 1 {
+            if i + 1 >= frames {
+                if c.looping && frames > 1 {
                    c.position = 0.0;
                    i = 0;
                } else {
@@ -639,13 +689,24 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
                }
            }
            let t = (c.position - i as f64) as f32;
-            let s = samples[i] * (1.0 - t) + samples[i + 1] * t;
-            if channels >= 2 {
-                frame[0] += s * left;
-                frame[1] += s * right;
+            if source_channels > 1 {
+                let l = samples[i * 2] * (1.0 - t) + samples[(i + 1) * 2] * t;
+                let r = samples[i * 2 + 1] * (1.0 - t) + samples[(i + 1) * 2 + 1] * t;
+                if channels >= 2 {
+                    frame[0] += l * left;
+                    frame[1] += r * right;
+                } else {
+                    frame[0] += (l + r) * 0.5 * gain;
+                }
            } else {
-                // A mono output has no panning: the source's own gain.
-                frame[0] += s * gain;
+                let s = samples[i] * (1.0 - t) + samples[i + 1] * t;
+                if channels >= 2 {
+                    frame[0] += s * left;
+                    frame[1] += s * right;
+                } else {
+                    // A mono output has no panning: the source's own gain.
+                    frame[0] += s * gain;
+                }
            }
            c.position += step;
        }
@@ -693,17 +754,27 @@ fn open_device(
 ) -> Result<(cpal::Stream, cpal::SupportedStreamConfig)> {
    use cpal::SampleFormat as F;
    let config = device.default_output_config()?;
-    let stream = match config.sample_format() {
-        F::F32 => build_stream::<f32>(device, &config, mixer.clone()),
-        F::F64 => build_stream::<f64>(device, &config, mixer.clone()),
-        F::I16 => build_stream::<i16>(device, &config, mixer.clone()),
-        F::I32 => build_stream::<i32>(device, &config, mixer.clone()),
-        F::I8 => build_stream::<i8>(device, &config, mixer.clone()),
-        F::U16 => build_stream::<u16>(device, &config, mixer.clone()),
-        F::U32 => build_stream::<u32>(device, &config, mixer.clone()),
-        F::U8 => build_stream::<u8>(device, &config, mixer.clone()),
+    let build = |stream_config: &cpal::StreamConfig| match config.sample_format() {
+        F::F32 => build_stream::<f32>(device, &config, stream_config, mixer.clone()),
+        F::F64 => build_stream::<f64>(device, &config, stream_config, mixer.clone()),
+        F::I16 => build_stream::<i16>(device, &config, stream_config, mixer.clone()),
+        F::I32 => build_stream::<i32>(device, &config, stream_config, mixer.clone()),
+        F::I8 => build_stream::<i8>(device, &config, stream_config, mixer.clone()),
+        F::U16 => build_stream::<u16>(device, &config, stream_config, mixer.clone()),
+        F::U32 => build_stream::<u32>(device, &config, stream_config, mixer.clone()),
+        F::U8 => build_stream::<u8>(device, &config, stream_config, mixer.clone()),
        other => Err(format!("unsupported sample format {other}").into()),
-    }?;
+    };
+    let short = audio_stream_config(&config);
+    let stream = match build(&short) {
+        Ok(stream) => stream,
+        // A device that refuses the short fixed buffer still plays with cpal's default one.
+        Err(e) if short != config.config() => {
+            log::info!("Horizon: audio output refused a short buffer ({e}); using the default");
+            build(&config.config())?
+        }
+        Err(e) => return Err(e),
+    };
    stream.play()?;
    if let Ok(mut m) = mixer.lock() {
        m.device_name = device.name().unwrap_or_default();
@@ -784,10 +855,58 @@ fn cards_changed(seen: Option<&str>, cards: Option<&str>) -> bool {
        _ => true,
    }
 }
+
+/// The buffer size to request for `open_device`. On Linux the ALSA backend's
+/// `BufferSize::Default` means a ~100 ms buffer, so sound effects come out
+/// about 100 ms late: request a short fixed buffer (1024 frames) by default.
+/// An environment override `HORIZON_AUDIO_BUFFER` can specify `default` or a
+/// custom frame count (e.g. 2048) when the default short buffer underruns
+/// (e.g. PipeWire min-quantum >= 1024).
+#[cfg(feature = "audio")]
+fn target_buffer_size(
+    range: (u32, u32),
+    var: impl Fn(&str) -> Option<std::ffi::OsString>,
+) -> Option<cpal::BufferSize> {
+    if let Some(val) = var("HORIZON_AUDIO_BUFFER").and_then(|v| v.into_string().ok()) {
+        if val == "default" {
+            return Some(cpal::BufferSize::Default);
+        }
+        if let Ok(frames) = val.parse::<u32>() {
+            return Some(cpal::BufferSize::Fixed(frames.clamp(range.0, range.1)));
+        }
+    }
+    #[cfg(target_os = "linux")]
+    {
+        Some(cpal::BufferSize::Fixed(1024u32.clamp(range.0, range.1)))
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        None
+    }
+}
+
+/// The cpal `StreamConfig` to open an output stream with. On Linux the ALSA
+/// backend's `BufferSize::Default` means a ~100 ms buffer, so sound effects
+/// come out about 100 ms late: request a short fixed buffer there. Other
+/// platforms keep cpal's default behaviour.
+#[cfg(feature = "audio")]
+fn audio_stream_config(config: &cpal::SupportedStreamConfig) -> cpal::StreamConfig {
+    let mut sc = config.config();
+    let range = match config.buffer_size() {
+        cpal::SupportedBufferSize::Range { min, max } => (*min, *max),
+        cpal::SupportedBufferSize::Unknown => (256, 4096),
+    };
+    if let Some(bs) = target_buffer_size(range, |name| std::env::var_os(name)) {
+        sc.buffer_size = bs;
+    }
+    sc
+}
+
 #[cfg(feature = "audio")]
 fn build_stream<T: cpal::SizedSample + cpal::FromSample<f32>>(
    device: &cpal::Device,
    config: &cpal::SupportedStreamConfig,
+    stream_config: &cpal::StreamConfig,
    mixer: Arc<Mutex<Mixer>>,
 ) -> Result<cpal::Stream> {
    let rate = config.sample_rate().0;
@@ -795,7 +914,7 @@ fn build_stream<T: cpal::SizedSample + cpal::FromSample<f32>>(
    let mut scratch = Vec::new();
    let on_error = mixer.clone();
    let stream = device.build_output_stream(
-        &config.config(),
+        stream_config,
        move |data: &mut [T], _| {
            scratch.resize(data.len(), 0.0f32);
            if let Ok(mut m) = mixer.lock() {
@@ -1262,7 +1381,17 @@ impl Audio {
    pub fn play_after(&mut self, event: &str, at: [f64; 3], volume: f32, pitch: f32, ticks: i32) {
        let seed = self.random.next_long();
        if let Some(capture) = self.capture.as_mut() {
-            capture.push((event.to_owned(), at, volume, pitch));
+            capture.push(CapturedSound {
+                event: event.to_owned(),
+                position: at,
+                volume,
+                pitch,
+                source: self.source_override.unwrap_or_else(|| {
+                    crate::settings::sound_source(&crate::sound_events::normalize(event))
+                }),
+                entity: None,
+                except_entity: None,
+            });
        }
        *self.heard.entry(event.to_owned()).or_default() += 1;
        self.sync_volumes();
@@ -1301,6 +1430,66 @@ impl Audio {
        preview.preview(self, source, volume);
        self.preview = preview;
    }
+    /// An incoming entity-sound packet: retain its seed and category without rebroadcasting it.
+    pub fn play_entity_seeded(
+        &mut self,
+        event: &str,
+        source: usize,
+        volume: f32,
+        pitch: f32,
+        seed: i64,
+        entity: crate::sound_engine::SoundEntity,
+    ) {
+        *self.heard.entry(event.to_owned()).or_default() += 1;
+        let event = crate::sound_events::normalize(event);
+        let instance = SoundInstance::entity_bound(
+            &event,
+            source,
+            volume,
+            pitch,
+            LegacyRandom::new(seed),
+            entity,
+        );
+        self.play_instance(instance, false);
+    }
+    /// A level's entity overload: preserve the emitter and excluded player for
+    /// the server broadcaster while the local sound follows the same object.
+    pub fn play_bound(
+        &mut self,
+        event: &str,
+        source: usize,
+        volume: f32,
+        pitch: f32,
+        entity: crate::sound_engine::SoundEntity,
+        except_entity: Option<u32>,
+    ) {
+        if let Some(capture) = self.capture.as_mut() {
+            capture.push(CapturedSound {
+                event: event.to_owned(),
+                position: entity.state().position,
+                volume,
+                pitch,
+                source,
+                entity: Some(entity.id),
+                except_entity,
+            });
+        }
+        let seed = self.random.next_long();
+        self.play_entity_seeded(event, source, volume, pitch, seed, entity);
+    }
+    /// Removal belongs to the old object even if its numeric id is immediately reused.
+    pub fn remove_sound_entity(&mut self, id: u32) {
+        for entity in self
+            .engine
+            .bound_entities()
+            .into_iter()
+            .filter(|e| e.id == id)
+        {
+            let mut state = entity.state();
+            state.removed = true;
+            entity.update(state);
+        }
+    }
    /// `play` with the seed a sound packet carries.
    pub fn play_seeded(
        &mut self,
@@ -1311,7 +1500,17 @@ impl Audio {
        seed: i64,
    ) {
        if let (Some(capture), Some(at)) = (self.capture.as_mut(), at) {
-            capture.push((event.to_owned(), at, volume, pitch));
+            capture.push(CapturedSound {
+                event: event.to_owned(),
+                position: at,
+                volume,
+                pitch,
+                source: self.source_override.unwrap_or_else(|| {
+                    crate::settings::sound_source(&crate::sound_events::normalize(event))
+                }),
+                entity: None,
+                except_entity: None,
+            });
        }
        if at.is_some() {
            *self.heard.entry(event.to_owned()).or_default() += 1;
@@ -1451,6 +1650,81 @@ impl Sounds for Audio {
 mod tests {
    use super::*;

+    #[test]
+    fn level_capture_keeps_order_category_entity_and_actor_exclusion() {
+        let mut audio = Audio::silent(Path::new("/nonexistent/horizon-entity-sound-test"));
+        audio.capture = Some(Vec::new());
+        let mut expected = audio.random.clone();
+        audio.play_on(
+            7,
+            "minecraft:block.amethyst_block.chime",
+            Some([1.0; 3]),
+            0.5,
+            1.0,
+        );
+        let entity = crate::sound_engine::SoundEntity::new(37, [2.123456789, 64.0, -3.0], false);
+        audio.play_bound(
+            "minecraft:block.amethyst_block.chime",
+            6,
+            2.0,
+            1.2,
+            entity,
+            Some(17),
+        );
+        let sounds = audio.capture.as_ref().unwrap();
+        assert_eq!(sounds.len(), 2);
+        assert_eq!(
+            (sounds[0].source, sounds[0].entity, sounds[0].except_entity),
+            (7, None, None)
+        );
+        let bound = &sounds[1];
+        assert_eq!(
+            (bound.source, bound.entity, bound.except_entity),
+            (6, Some(37), Some(17))
+        );
+        assert_eq!(bound.position, [2.123456789, 64.0, -3.0]);
+        assert_eq!((bound.volume, bound.pitch), (2.0, 1.2));
+        expected.next_long();
+        expected.next_long();
+        assert_eq!(audio.random.next_long(), expected.next_long());
+    }
+
+    #[test]
+    fn entity_sound_packets_neither_rebroadcast_nor_advance_the_local_seed_generator() {
+        let mut audio = Audio::silent(Path::new("/nonexistent/horizon-entity-sound-test"));
+        audio.capture = Some(Vec::new());
+        let mut expected = audio.random.clone();
+        let entity = crate::sound_engine::SoundEntity::new(7, [1.0, 2.0, 3.0], false);
+        audio.play_entity_seeded("minecraft:fixture.bound", 6, 0.7, 1.2, 42, entity);
+        assert!(audio.capture.as_ref().unwrap().is_empty());
+        assert_eq!(audio.random.next_long(), expected.next_long());
+    }
+    #[test]
+    fn removal_marks_only_existing_references_to_that_entity() {
+        use crate::sound_engine::SoundEntity;
+        let mut audio = Audio::silent(Path::new("/nonexistent/horizon-entity-sound-test"));
+        let old = SoundEntity::new(7, [0.0; 3], false);
+        let other = SoundEntity::new(8, [0.0; 3], false);
+        for entity in [old.clone(), other.clone()] {
+            audio.engine.add(
+                SoundInstance::entity_bound(
+                    "minecraft:fixture.bound",
+                    6,
+                    1.0,
+                    1.0,
+                    LegacyRandom::new(42),
+                    entity,
+                ),
+                true,
+            );
+        }
+        audio.remove_sound_entity(7);
+        let replacement = SoundEntity::new(7, [10.0; 3], false);
+        assert!(old.state().removed);
+        assert!(!other.state().removed);
+        assert!(!replacement.state().removed);
+    }
+
    #[test]
    fn button_click_uses_vanilla_ui_parameters_without_advancing_world_random() {
        let mut audio = Audio::silent(Path::new("/nonexistent/horizon-test-assets"));
@@ -1485,7 +1759,7 @@ mod tests {

    fn channel(samples: Vec<f32>, linear: Option<f32>, at: [f32; 3], looping: bool) -> Channel {
        Channel {
-            samples: Some((Arc::new(samples), 48_000)),
+            samples: Some((Arc::new(samples), 48_000, 1)),
            position: 0.0,
            state: State::Playing,
            gain: 1.0,
@@ -1500,11 +1774,23 @@ mod tests {
        }
    }

+    /// A channel whose buffer is interleaved stereo.
+    fn stereo_channel(
+        samples: Vec<f32>,
+        linear: Option<f32>,
+        at: [f32; 3],
+        looping: bool,
+    ) -> Channel {
+        let mut c = channel(Vec::new(), linear, at, looping);
+        c.samples = Some((Arc::new(samples), 48_000, 2));
+        c
+    }
+
    #[test]
    fn decoded_sounds_stay_within_the_budget_least_recently_used_out() {
        let mut cache = SoundCache::default();
        let quarter = CACHE_BYTES / 4 / std::mem::size_of::<f32>();
-        let sound = || Some((Arc::new(vec![0.0f32; quarter]), 44100));
+        let sound = || Some((Arc::new(vec![0.0f32; quarter]), 44100, 1));
        for key in ["a", "b", "c", "d"] {
            cache.insert(key.into(), sound());
        }
@@ -1542,6 +1828,42 @@ mod tests {
        );
    }
    #[test]
+    #[cfg(feature = "audio")]
+    fn buffer_size_override_and_defaults() {
+        let env = |pairs: &'static [(&'static str, &'static str)]| {
+            move |name: &str| {
+                pairs
+                    .iter()
+                    .find(|(k, _)| *k == name)
+                    .map(|(_, v)| std::ffi::OsString::from(*v))
+            }
+        };
+        let range = (256, 4096);
+        assert_eq!(
+            target_buffer_size(range, env(&[("HORIZON_AUDIO_BUFFER", "default")])),
+            Some(cpal::BufferSize::Default)
+        );
+        assert_eq!(
+            target_buffer_size(range, env(&[("HORIZON_AUDIO_BUFFER", "2048")])),
+            Some(cpal::BufferSize::Fixed(2048))
+        );
+        assert_eq!(
+            target_buffer_size(range, env(&[("HORIZON_AUDIO_BUFFER", "100")])),
+            Some(cpal::BufferSize::Fixed(256))
+        );
+        assert_eq!(
+            target_buffer_size(range, env(&[("HORIZON_AUDIO_BUFFER", "10000")])),
+            Some(cpal::BufferSize::Fixed(4096))
+        );
+        #[cfg(target_os = "linux")]
+        assert_eq!(
+            target_buffer_size(range, env(&[])),
+            Some(cpal::BufferSize::Fixed(1024))
+        );
+        #[cfg(not(target_os = "linux"))]
+        assert_eq!(target_buffer_size(range, env(&[])), None);
+    }
+    #[test]
    fn linear_attenuation_reaches_zero_at_the_max_distance() {
        assert_eq!(distance_gain(None, 100.0), 1.0);
        assert_eq!(distance_gain(Some(16.0), 0.0), 1.0);
@@ -1631,6 +1953,32 @@ mod tests {
        }
    }

+    #[test]
+    fn stereo_sounds_play_direct_without_panning_or_distance() {
+        // OpenAL Soft plays a multi-channel buffer direct (its non-spatialized path), so vanilla's
+        // stereo music and records keep their own left/right mix at full volume whichever way the
+        // camera faces and however far it is. Only mono buffers are panned and attenuated.
+        let wave = [0.1, -0.2, 0.3, -0.4, 0.5, -0.6]; // three stereo frames
+        let expected = [wave[0], wave[1], wave[2], wave[3]];
+        for (yaw, at, linear, listener) in [
+            (0.0, [100.0, 0.0, 0.0], Some(16.0), [0.0; 3]),
+            (180.0, [0.0, 0.0, -100.0], Some(16.0), [0.0; 3]),
+            (90.0, [2.0, 1.0, -3.0], Some(16.0), [5.0, 60.0, 5.0]),
+            (0.0, [0.0, 0.0, 0.0], None, [0.0; 3]),
+        ] {
+            let mut m = Mixer {
+                listener,
+                listener_yaw: yaw,
+                ..Mixer::default()
+            };
+            m.channels
+                .insert(1, stereo_channel(wave.to_vec(), linear, at, false));
+            let mut data = [0.0; 4];
+            mix(&mut m, &mut data, 2, 48_000);
+            assert_eq!(data, expected, "yaw {yaw}, source {at:?}");
+        }
+    }
+
    #[test]
    fn panning_follows_the_camera_rotation() {
        let gains = |yaw: f32, pitch: f32, at: [f32; 3]| {
@@ -49,6 +49,10 @@ impl AuthSession {
            access_token: access_token.to_owned(),
        }
    }
+
+    pub fn access_token(&self) -> &str {
+        &self.access_token
+    }
    /// The session file's JSON: {"name", "uuid", "access_token", "user_type": "msa", "xuid"}.
    pub fn parse(text: &str) -> Result<Self, String> {
        let v: serde_json::Value =
@@ -288,7 +288,7 @@ impl Biomes {
            .collect();
        files.sort_by_cached_key(|f| format!("{}.json", f.name));
        for file in files {
-            let v: Value = serde_json::from_slice(file.bytes()?)?;
+            let v: Value = horizon_world::json_file::parse(&file.path, file.bytes()?)?;
            list.push(BiomeInfo::from_json(
                format!("minecraft:{}", file.name),
                &v,
@@ -89,6 +89,7 @@ pub struct BlockEntities {
    /// instance blocks, `shows_box`), so a frame looks at them without scanning the map.
    /// Like `mods`, one taken out stays listed until `put` or `remove`.
    boxes: FxHashSet<Pos>,
+    asleep: FxHashSet<Pos>,
 }

 /// A structure or test instance block: the block entities whose box the frame may draw.
@@ -229,6 +230,7 @@ impl BlockEntities {
    }
    /// `removeBlockEntityTicker`: no slot, made or pending.
    fn cancel(&mut self, pos: &Pos) {
+        self.asleep.remove(pos);
        self.freed |= self.live.remove(pos).is_some();
        self.pending.remove(pos);
    }
@@ -297,14 +299,25 @@ impl BlockEntities {
        self.map.get(pos)
    }
    pub fn get_mut(&mut self, pos: &Pos) -> Option<&mut BlockEntity> {
+        self.asleep.remove(pos);
        self.map.get_mut(pos)
    }
    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&Pos, &mut BlockEntity)> {
+        self.asleep.clear();
        self.map.iter_mut()
    }
    pub fn values_mut(&mut self) -> impl Iterator<Item = &mut BlockEntity> {
+        self.asleep.clear();
        self.map.values_mut()
    }
+    pub fn sleep(&mut self, pos: Pos) {
+        if self.map.contains_key(&pos) {
+            self.asleep.insert(pos);
+        }
+    }
+    pub fn is_asleep(&self, pos: &Pos) -> bool {
+        self.asleep.contains(pos)
+    }
    /// `LevelChunk.setBlockEntity` (+ `addAndRegisterBlockEntity`): a new
    /// block entity may get a slot; one replacing another keeps its slot.
    /// One of the same type rewrites it in place (a jukebox taking a disc,
@@ -320,6 +333,7 @@ impl BlockEntities {
            self.attachments.remove(&pos);
        }
        let new_box = shows_box(&entity);
+        self.asleep.remove(&pos);
        let old = self.map.insert(pos, entity);
        if old.is_none() {
            self.add(pos);
@@ -346,6 +360,7 @@ impl BlockEntities {
        if absent {
            self.add(pos);
        }
+        self.asleep.remove(&pos);
        let entity = self.map.entry(pos).or_insert_with(make);
        if absent && matches!(entity, BlockEntity::Mod(_)) {
            self.mods.entry(chunk_of(pos)).or_default().insert(pos);
@@ -358,6 +373,7 @@ impl BlockEntities {
    /// `LevelChunk.removeBlockEntity`: the block entity and its slot.
    pub fn remove(&mut self, pos: &Pos) -> Option<BlockEntity> {
        self.attachments.remove(pos);
+        self.asleep.remove(pos);
        self.cancel(pos);
        let removed = self.map.remove(pos);
        if matches!(removed, Some(BlockEntity::Mod(_))) {
@@ -369,6 +385,7 @@ impl BlockEntities {
    /// The block entity at `pos`, out of the map for a while: its slot stays
    /// for `put` to bring it back (a tick working on it).
    pub fn take(&mut self, pos: &Pos) -> Option<BlockEntity> {
+        self.asleep.remove(pos);
        let taken = self.map.remove(pos);
        if taken.is_some() {
            self.out.insert(*pos);
@@ -378,6 +395,7 @@ impl BlockEntities {
    /// Brings back what `take` took, in its slot.
    pub fn put(&mut self, pos: Pos, entity: BlockEntity) {
        self.out.remove(&pos);
+        self.asleep.remove(&pos);
        if matches!(entity, BlockEntity::Mod(_)) {
            self.mods.entry(chunk_of(pos)).or_default().insert(pos);
        }
@@ -389,6 +407,16 @@ impl BlockEntities {
            self.add(pos);
        }
    }
+    /// [`Self::retain`] for unloading chunks: removes the block entities at
+    /// the positions `gone` names and changes none it keeps, so those that
+    /// sleep stay asleep (a moving player unloads chunks most ticks).
+    pub fn unload(&mut self, mut gone: impl FnMut(&Pos) -> bool) {
+        let asleep = std::mem::take(&mut self.asleep);
+        self.retain(|p, _| !gone(p));
+        self.asleep = asleep;
+        let map = &self.map;
+        self.asleep.retain(|p| map.contains_key(p));
+    }
    /// Removes the block entities `keep` refuses, and their slots
    /// (`clearAllBlockEntities` of unloaded chunks).
    pub fn retain(&mut self, mut keep: impl FnMut(&Pos, &mut BlockEntity) -> bool) {
@@ -399,6 +427,7 @@ impl BlockEntities {
            &mut self.attachments,
        );
        let (mods, boxes) = (&mut self.mods, &mut self.boxes);
+        self.asleep.clear();
        self.map.retain(|p, e| {
            let kept = keep(p, e);
            if !kept {
@@ -416,6 +445,7 @@ impl BlockEntities {
        self.map.clear();
        self.mods.clear();
        self.boxes.clear();
+        self.asleep.clear();
        self.tickers = Arc::default();
        self.live.clear();
        self.added.clear();
@@ -433,6 +463,7 @@ impl BlockEntities {
        let order = chunk_map_order(entities.iter().map(|(p, _)| *p));
        for (p, e) in entities {
            self.attachments.remove(&p);
+            self.asleep.remove(&p);
            let new_is_mod = matches!(e, BlockEntity::Mod(_));
            self.note_box(p, Some(&e));
            let old = self.map.insert(p, e);
@@ -452,6 +483,7 @@ impl BlockEntities {
    /// `LevelChunk.setBlockState` on a block entity's position, from state
    /// `old` to `new`: a ticker made, kept or dropped.
    pub fn state_changed(&mut self, pos: Pos, old: u32, new: u32) {
+        self.asleep.remove(&pos);
        if self.states.is_empty() || !self.map.contains_key(&pos) {
            return;
        }
@@ -536,12 +568,75 @@ mod tests {
            .collect()
    }

+    /// Unloading a chunk removes its block entities and leaves the others'
+    /// sleep alone; `retain`, which may change what it keeps, wakes them all.
+    #[test]
+    fn unloading_a_chunk_keeps_the_others_asleep() {
+        let mut b = level();
+        let (kept, gone) = ((1, 64, 1), (17, 64, 1));
+        b.insert(kept, hopper());
+        b.insert(gone, hopper());
+        b.sleep(kept);
+        b.sleep(gone);
+        b.unload(|p| p.0 >> 4 == 1);
+        assert!(b.get(&gone).is_none());
+        assert!(!b.is_asleep(&gone));
+        assert!(b.is_asleep(&kept));
+        b.retain(|_, _| true);
+        assert!(!b.is_asleep(&kept));
+    }
+
    fn near(b: &BlockEntities, x: f64, z: f64, radius: f64) -> Vec<Pos> {
        let mut found: Vec<Pos> = b.mods_near(x, z, radius).copied().collect();
        found.sort();
        found
    }
    #[test]
+    fn a_sleeping_block_entity_wakes_on_any_change() {
+        let p = (1, 64, 1);
+        let mut b = level();
+        b.sleep(p);
+        assert!(!b.is_asleep(&p));
+        b.insert(p, hopper());
+        let asleep = |b: &mut BlockEntities, wake: &dyn Fn(&mut BlockEntities)| {
+            b.sleep(p);
+            assert!(b.is_asleep(&p));
+            wake(b);
+            b.is_asleep(&p)
+        };
+        assert!(asleep(&mut b, &|_| {}));
+        assert!(!asleep(&mut b, &|b| {
+            b.get_mut(&p);
+        }));
+        assert!(!asleep(&mut b, &|b| {
+            b.insert(p, hopper());
+        }));
+        assert!(!asleep(&mut b, &|b| {
+            b.get_or_insert_with(p, hopper);
+        }));
+        assert!(!asleep(&mut b, &|b| {
+            let held = b.take(&p).unwrap();
+            b.put(p, held);
+        }));
+        assert!(!asleep(&mut b, &|b| b.state_changed(p, 1, 1)));
+        assert!(!asleep(&mut b, &|b| b.forget(&p)));
+        assert!(!asleep(&mut b, &|b| {
+            b.iter_mut().count();
+        }));
+        assert!(!asleep(&mut b, &|b| {
+            b.values_mut().count();
+        }));
+        assert!(!asleep(&mut b, &|b| b.retain(|_, _| true)));
+        assert!(!asleep(&mut b, &|b| b.load_chunk(vec![(p, hopper())])));
+        assert!(!asleep(&mut b, &|b| {
+            b.remove(&p);
+            b.insert(p, hopper());
+        }));
+        b.sleep(p);
+        b.clear();
+        assert!(!b.is_asleep(&p));
+    }
+    #[test]
    fn mod_block_entities_are_listed_by_chunk_until_they_go() {
        let mut b = level();
        let modded = || BlockEntity::Mod(Box::default());
@@ -7,7 +7,7 @@
 //! the block plus `minecraft_mix_light` with the level's two diffuse lights.
 use crate::{
    Result,
-    bidi::visual_str,
+    bidi::visual,
    block_entity_anim::{self, EnchantingBook},
    breaking::entity_geometry,
    fast_hash::FxHashMap,
@@ -271,10 +271,10 @@ pub const DYES: [(&str, u32); 16] = [
    ("black", 0x1D1D21),
 ];
 fn dye_prefix(name: &str) -> Option<(usize, &str)> {
-    // Longest names first so "light_gray" wins over "gray".
-    let mut order: Vec<usize> = (0..16).collect();
-    order.sort_by_key(|&i| std::cmp::Reverse(DYES[i].0.len()));
-    order.into_iter().find_map(|i| {
+    // Longest names first; this is the same stable order as sorting DYES by
+    // descending prefix length, without a Vec allocation or comparison sort.
+    const ORDER: [usize; 16] = [3, 8, 2, 1, 4, 10, 0, 12, 13, 15, 5, 6, 7, 9, 11, 14];
+    ORDER.into_iter().find_map(|i| {
        name.strip_prefix(DYES[i].0)
            .and_then(|rest| rest.strip_prefix('_'))
            .map(|rest| (i, rest))
@@ -639,7 +639,9 @@ fn sign_text_near(pos: [i32; 3], camera: DVec3) -> bool {
 }

 /// `AbstractSignRenderer.submitSignText`: four centred lines, glowing text
-/// full-bright with an 8x outline in the dark colour.
+/// full-bright with an 8x outline in the dark colour. The font colours each
+/// glyph by its style (`Font.StringRenderOutput`): a line's own colour wins,
+/// else the sign's. A line is one call per run of one colour.
 fn sign_text_calls(
    scene: &Scene,
    data: &SignData,
@@ -662,25 +664,53 @@ fn sign_text_calls(
        (dark, 0, vertex_light(packed))
    };
    let advance = |c: char| (scene.glyph)(c).advance;
-    let width = |s: &str| s.chars().map(advance).sum::<f32>().ceil();
-    text.lines
-        .iter()
-        .enumerate()
-        .map(|(i, line)| {
-            // The line that fits, in the order it is drawn (getVisualOrder).
-            let shown = first_line(line, data.max_line_width(), &advance);
-            let shown = visual_str(&shown).into_owned();
-            TextCall {
+    let mut calls: Vec<TextCall> = Vec::with_capacity(text.lines.len());
+    for i in 0..text.lines.len() {
+        // The line that fits, in the order it is drawn (getVisualOrder).
+        let line = text.line_text(i);
+        let line = line.resolved();
+        let flat: String = line.chars().map(|(c, _)| c).collect();
+        let fits = first_line(&flat, data.max_line_width(), &advance);
+        let shown = line.slice(0, fits.chars().count());
+        let shown = visual(&shown);
+        let width = shown.chars().map(|(c, _)| advance(c)).sum::<f32>().ceil();
+        let x = -((width as i32) / 2) as f32;
+        let y = i as f32 * line_height - midpoint;
+        let first = calls.len();
+        let mut pen = 0.0;
+        for span in shown.spans.iter().filter(|s| !s.text.is_empty()) {
+            let run = span
+                .style
+                .color
+                .map_or(color, |rgb| 0xFF00_0000 | (rgb & 0xFF_FFFF));
+            match calls[first..].last_mut() {
+                Some(last) if last.color == run => last.text.push_str(&span.text),
+                _ => calls.push(TextCall {
+                    matrix: m,
+                    x: x + pen,
+                    y,
+                    text: span.text.clone(),
+                    color: run,
+                    outline,
+                    light,
+                }),
+            }
+            pen += span.text.chars().map(advance).sum::<f32>();
+        }
+        if calls.len() == first {
+            // A line with no text is still a call, of no glyphs.
+            calls.push(TextCall {
                matrix: m,
-                x: -((width(&shown) as i32) / 2) as f32,
-                y: i as f32 * line_height - midpoint,
-                text: shown,
+                x,
+                y,
+                text: String::new(),
                color,
                outline,
                light,
-            }
-        })
-        .collect()
+            });
+        }
+    }
+    calls
 }

 /// How far the text of an outlined call sits in front of its outline, in
@@ -696,11 +726,19 @@ const TEXT_OVER_OUTLINE: f32 = 0.05;
 /// reader instead (a twentieth of a font pixel, invisible) rather than
 /// z-fighting with the outline under it.
 fn draw_text(scene: &Scene, call: &TextCall, out: &mut Vec<Vertex>) {
+    text_vertices(scene.glyph, call, out);
+}
+
+/// `draw_text` with the font's glyph cells and advances from `glyph`: the
+/// text of `call` as glyph quads in its matrix's plane, 1 unit a font pixel,
+/// y down as the font's, with its outline when it has one. A native mod's
+/// block entity draws its text this way (`native_draw_text`).
+pub fn text_vertices(glyph: &dyn Fn(char) -> Glyph, call: &TextCall, out: &mut Vec<Vertex>) {
    let mut emit = |dx: f32, dy: f32, z: f32, argb: u32| {
        let mut x = call.x + dx;
        let y0 = call.y + dy;
        for ch in call.text.chars() {
-            let g = (scene.glyph)(ch);
+            let g = glyph(ch);
            if let Some(cell) = g.rect {
                // BakedSheetGlyph: the glyph's own box from the pen, not a
                // fixed 8x8 cell (a Unifont glyph is 0.5 units per texel).
@@ -833,6 +871,9 @@ pub struct Scene<'a> {
    /// Changes whenever `glyph` may answer differently (`Font::epoch`): sign
    /// text laid out under another value is laid out again.
    pub glyphs: u64,
+    /// Per-block visibility for dynamic, animated, or uncached models. Bounds
+    /// are world-space and conservatively include model animation extents.
+    pub dynamic_visible: Option<&'a dyn Fn([i32; 3], u32, DVec3, DVec3) -> bool>,
 }

 /// Empty by default (a dedicated server): no state has a block entity model.
@@ -1402,6 +1443,167 @@ impl BlockEntityRenderer {
    fn kind(&self, state: u32) -> &Kind {
        self.kinds.get(state as usize).unwrap_or(&Kind::None)
    }
+    fn dynamic_bounds(
+        &self,
+        scene: &Scene,
+        pos: [i32; 3],
+        kind: &Kind,
+        chest_openness: Option<(f32, Option<[i32; 3]>)>,
+    ) -> (DVec3, DVec3) {
+        let [x, y, z] = pos.map(f64::from);
+        let mut lo = DVec3::new(x, y, z);
+        let mut hi = DVec3::new(x + 1.0, y + 1.0, z + 1.0);
+        match kind {
+            Kind::Chest { double_with, .. } => {
+                if let Some(offset) = double_with {
+                    lo.x += f64::from(offset[0].min(0));
+                    lo.z += f64::from(offset[2].min(0));
+                    hi.x += f64::from(offset[0].max(0));
+                    hi.z += f64::from(offset[2].max(0));
+                }
+                let is_open = chest_openness.map_or_else(
+                    || {
+                        (scene.lid)(pos) != 0.0
+                            || double_with.is_some_and(|offset| {
+                                let other = [
+                                    pos[0].saturating_add(offset[0]),
+                                    pos[1].saturating_add(offset[1]),
+                                    pos[2].saturating_add(offset[2]),
+                                ];
+                                (scene.lid)(other) != 0.0
+                            })
+                    },
+                    |(open, _)| open != 0.0,
+                );
+                if is_open {
+                    // The lid pivots up from the rear edge. Its longest corner
+                    // rises by less than one block in the fully open pose.
+                    hi.y += 0.8;
+                }
+            }
+            Kind::Shulker { facing, .. } => {
+                let offset = step(facing);
+                lo.x += f64::from(offset[0].min(0)) * 0.52;
+                lo.y += f64::from(offset[1].min(0)) * 0.52;
+                lo.z += f64::from(offset[2].min(0)) * 0.52;
+                hi.x += f64::from(offset[0].max(0)) * 0.52;
+                hi.y += f64::from(offset[1].max(0)) * 0.52;
+                hi.z += f64::from(offset[2].max(0)) * 0.52;
+            }
+            Kind::Banner { wall: false, .. } => {
+                hi.y += 1.0;
+                lo.x -= 0.05;
+                lo.z -= 0.05;
+                hi.x += 0.05;
+                hi.z += 0.05;
+            }
+            Kind::Banner { wall: true, .. } => {
+                lo.y -= 1.0;
+                lo.x -= 0.05;
+                lo.z -= 0.05;
+                hi.x += 0.05;
+                hi.z += 0.05;
+            }
+            Kind::Sign { hanging: true, .. } => {
+                lo.y -= 1.0;
+                lo.x -= 0.15;
+                lo.z -= 0.15;
+                hi.x += 0.15;
+                hi.z += 0.15;
+            }
+            Kind::Sign { hanging: false, .. } => {
+                hi.y += 0.3;
+                lo.x -= 0.02;
+                lo.z -= 0.02;
+                hi.x += 0.02;
+                hi.z += 0.02;
+            }
+            Kind::EnchantingTable | Kind::Lectern { .. } => {
+                // The book and statue models rise above the block's collision
+                // cube; include their full rendered height and rotated corners.
+                hi.y += 1.0;
+                lo.x -= 0.25;
+                lo.z -= 0.25;
+                hi.x += 0.25;
+                hi.z += 0.25;
+            }
+            Kind::CopperGolem { .. } => {
+                // The statue pose rotates around the root, so some variants
+                // extend below the block as well as above it.
+                lo.y -= 1.0;
+                hi.y += 1.0;
+                lo.x -= 0.25;
+                lo.z -= 0.25;
+                hi.x += 0.25;
+                hi.z += 0.25;
+            }
+            Kind::Conduit => {
+                // Its animated cage is centered above the conduit block and
+                // the wind model spans multiple cells. The caller bypasses
+                // voxel occlusion for envelopes this tall, but retains frustum
+                // culling with this conservative volume.
+                lo.x -= 1.0;
+                lo.y -= 1.0;
+                lo.z -= 1.0;
+                hi.x += 1.0;
+                hi.y += 1.0;
+                hi.z += 1.0;
+            }
+            Kind::Bell => {
+                // The bell's pivoted swing moves its corners slightly outside
+                // the block even though the model starts centered in it.
+                lo.x -= 0.1;
+                lo.y -= 0.1;
+                lo.z -= 0.1;
+                hi.x += 0.1;
+                hi.y += 0.1;
+                hi.z += 0.1;
+            }
+            Kind::Skull { .. } => {
+                // Wall-mounted and dragon heads can protrude from their block.
+                lo.x -= 0.25;
+                lo.y -= 0.25;
+                lo.z -= 0.25;
+                hi.x += 0.25;
+                hi.y += 0.25;
+                hi.z += 0.25;
+            }
+            Kind::EndGateway { .. } => {
+                let anim = (scene.anim)(pos);
+                let beam = gateway_beam(anim.gateway, scene.partial, scene.max_y, scene.game_time);
+                let height = f64::from(beam.height.max(0));
+                lo.y -= height;
+                hi.y += height;
+            }
+            _ => {}
+        }
+        (lo, hi)
+    }
+
+    fn is_dynamic_visible(
+        &self,
+        scene: &Scene,
+        shapes: &Arc<BlockEntityShapes>,
+        pos: [i32; 3],
+        state: u32,
+        kind: &Kind,
+        chest_openness: Option<(f32, Option<[i32; 3]>)>,
+    ) -> bool {
+        let Some(visible) = scene.dynamic_visible else {
+            return true;
+        };
+        if matches!(kind, Kind::EndGateway { .. }) {
+            return true;
+        }
+        // A pack model may extend outside the vanilla envelope. Keep that
+        // geometry on the uncullable path unless its model bounds are known.
+        if !Arc::ptr_eq(shapes, &self.vanilla) {
+            return true;
+        }
+        let (lo, hi) = self.dynamic_bounds(scene, pos, kind, chest_openness);
+        visible(pos, state, lo, hi)
+    }
+
    fn cached_entry_is_current(
        &self,
        scene: &Scene,
@@ -1411,6 +1613,7 @@ impl BlockEntityRenderer {
        options: CacheOptions,
        entry: &StaticEntry,
        section_revision: StaticSectionRevision,
+        chest_openness: Option<(f32, Option<[i32; 3]>)>,
    ) -> bool {
        if entry.key.state != state
            || entry.key.nether != scene.nether
@@ -1422,15 +1625,24 @@ impl BlockEntityRenderer {
        }
        match kind {
            Kind::Chest { .. } => {
-                let (open, other) = self.chest_openness(
-                    pos,
-                    kind,
-                    &|p| scene.world.block(p[0], p[1], p[2]).0,
-                    scene.lid,
-                );
-                // Double chests depend on the neighboring half's light too;
-                // let those uncommon models take the full key path.
-                open == 0.0 && other.is_none()
+                let (open, other) = chest_openness.unwrap_or_else(|| {
+                    self.chest_openness(
+                        pos,
+                        kind,
+                        &|p| scene.world.block(p[0], p[1], p[2]).0,
+                        scene.lid,
+                    )
+                });
+                if open != 0.0 {
+                    return false;
+                }
+                let mut light = scene.world.light(pos[0], pos[1], pos[2]);
+                if let Some(other) = other {
+                    let other_light = scene.world.light(other[0], other[1], other[2]);
+                    light = (light >> 4).max(other_light >> 4) << 4
+                        | (light & 15).max(other_light & 15);
+                }
+                entry.key.light == light
            }
            Kind::Shulker { .. } => {
                let (progress, old) = (scene.anim)(pos).shulker;
@@ -1693,6 +1905,17 @@ impl BlockEntityRenderer {
                }
                let local = static_local_index(pos, section_min_y);
                let current_section_revision = active_section_revision.unwrap_or_default();
+                let chest_openness = (cache.is_some()
+                    && options.chests
+                    && matches!(kind, Kind::Chest { .. }))
+                .then(|| {
+                    self.chest_openness(
+                        pos,
+                        kind,
+                        &|p| scene.world.block(p[0], p[1], p[2]).0,
+                        scene.lid,
+                    )
+                });
                if cache_only && section_revision.is_some() && active_section_revision.is_none() {
                    break 'draw;
                }
@@ -1708,6 +1931,7 @@ impl BlockEntityRenderer {
                        options,
                        &active_entries[index].1,
                        current_section_revision,
+                        chest_openness,
                    )
                {
                    let entry = &mut active_entries[index].1;
@@ -1727,7 +1951,9 @@ impl BlockEntityRenderer {
                            ..*vertex
                        }));
                    }
-                    if matches!(kind, Kind::Banner { .. }) {
+                    if matches!(kind, Kind::Banner { .. })
+                        && self.is_dynamic_visible(scene, &shapes, pos, state, kind, None)
+                    {
                        let packed = scene.world.light(pos[0], pos[1], pos[2]);
                        let origin =
                            (DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]))
@@ -1748,11 +1974,25 @@ impl BlockEntityRenderer {
                    }
                    break 'draw;
                }
+                if cache_only && chest_openness.is_some_and(|(open, _)| open != 0.0) {
+                    if let Some(cache) = &mut cache
+                        && let Ok(index) =
+                            active_entries.binary_search_by_key(&local, |(index, _)| *index)
+                    {
+                        active_entries.remove(index);
+                        cache.len -= 1;
+                        cache.mark_section_dirty(section);
+                    }
+                    break 'draw;
+                }
                let origin = (DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]))
                    - scene.camera)
                    .as_vec3();
                let mut packed = scene.world.light(pos[0], pos[1], pos[2]);
                if matches!(kind, Kind::Sign { .. }) && scene.texts.is_none() {
+                    if !self.is_dynamic_visible(scene, &shapes, pos, state, kind, None) {
+                        break 'draw;
+                    }
                    if options.signs {
                        self.sign_text(scene, pos, state, origin, packed, out);
                    } else {
@@ -1771,8 +2011,15 @@ impl BlockEntityRenderer {
                    break 'draw;
                }
                if let Some(cache) = &mut cache
-                    && let Some(key) =
-                        self.static_key(scene, pos, state, kind, options, &mut packed)
+                    && let Some(key) = self.static_key(
+                        scene,
+                        pos,
+                        state,
+                        kind,
+                        options,
+                        &mut packed,
+                        chest_openness,
+                    )
                {
                    let slot = active_entries.binary_search_by_key(&local, |(index, _)| *index);
                    let entry = match slot {
@@ -1857,7 +2104,9 @@ impl BlockEntityRenderer {
                            ..*vertex
                        }));
                    }
-                    if matches!(kind, Kind::Banner { .. }) {
+                    if matches!(kind, Kind::Banner { .. })
+                        && self.is_dynamic_visible(scene, &shapes, pos, state, kind, None)
+                    {
                        self.render_banner(
                            &shapes,
                            scene,
@@ -1884,6 +2133,9 @@ impl BlockEntityRenderer {
                if cache_only {
                    break 'draw;
                }
+                if !self.is_dynamic_visible(scene, &shapes, pos, state, kind, chest_openness) {
+                    break 'draw;
+                }
                let base = Mat4::from_translation(origin);
                self.render_one(scene, pos, kind, base, packed, lights, false, true, out);
            }
@@ -1950,6 +2202,7 @@ impl BlockEntityRenderer {
        kind: &Kind,
        options: CacheOptions,
        packed: &mut u8,
+        chest_openness: Option<(f32, Option<[i32; 3]>)>,
    ) -> Option<StaticKey> {
        let mut sprite_rects = [None; 5];
        let mut sprite_count = 0;
@@ -1967,12 +2220,14 @@ impl BlockEntityRenderer {
                part,
                ..
            } if options.chests => {
-                let (open, other) = self.chest_openness(
-                    pos,
-                    kind,
-                    &|p| scene.world.block(p[0], p[1], p[2]).0,
-                    scene.lid,
-                );
+                let (open, other) = chest_openness.unwrap_or_else(|| {
+                    self.chest_openness(
+                        pos,
+                        kind,
+                        &|p| scene.world.block(p[0], p[1], p[2]).0,
+                        scene.lid,
+                    )
+                });
                if open != 0.0 {
                    return None;
                }
@@ -3152,7 +3407,9 @@ impl BeamPart {
                (at(b, self.end), [s.u0, v1]),
            ] {
                out.push(Vertex {
-                    normal: [0; 4],
+                    // The beacon beam render types keep the default back-face culling: seen
+                    // from inside a beam, its walls must not show.
+                    normal: CULL_BACK,
                    pos: p.to_array(),
                    uv,
                    layer: 6,
@@ -3242,6 +3499,7 @@ fn portal_cube(m: Mat4, faces: &[Direction], layer: u32, out: &mut Vec<Vertex>)
 mod tests {
    use super::*;
    use crate::assets::Assets;
+    use horizon_world::nbt::Tag;
    #[test]
    #[ignore = "requires prepared models/textures in HORIZON_TEST_RESOURCES"]
    fn entity_block_particles_and_breaking_use_exported_models() -> Result<()> {
@@ -3354,6 +3612,7 @@ mod tests {
            skull: &|_| None,
            glyph: &|_| Glyph::default(),
            glyphs: 0,
+            dynamic_visible: None,
        };
        // Compare the cached world path with the original model renderer,
        // including atlas replacement, current light and animated fallback.
@@ -3648,6 +3907,7 @@ mod tests {
            skull: &|_| None,
            glyph: &glyph,
            glyphs: 0,
+            dynamic_visible: None,
        };
        let mut call = TextCall {
            matrix: Mat4::IDENTITY,
@@ -3720,6 +3980,7 @@ mod tests {
            skull: &|_| None,
            glyph: &glyph,
            glyphs: 0,
+            dynamic_visible: None,
        };
        let call = TextCall {
            matrix: Mat4::IDENTITY,
@@ -3748,6 +4009,129 @@ mod tests {
        assert_eq!(boxes, [[10.0, 14.0, 2.0, 10.0], [15.0, 19.0, 2.0, 10.0]]);
    }

+    /// The front text calls of a sign whose every glyph advances 6.
+    fn front_calls(data: &SignData, near: bool) -> Vec<(String, f32, f32, u32, u32)> {
+        let world = World::new(BlockStateId(0), 1);
+        let sprites = HashMap::new();
+        let glyph = |_: char| Glyph {
+            advance: 6.0,
+            ..Glyph::default()
+        };
+        let scene = Scene {
+            camera: DVec3::ZERO,
+            orientation: Quat::IDENTITY,
+            anim: &|_| BlockAnim::default(),
+            texts: None,
+            partial: 0.0,
+            game_time: 0,
+            max_y: 320,
+            world: &world,
+            sprites: &sprites,
+            emissive: &Default::default(),
+            translucent_sprites: &HashSet::new(),
+            atlas_revision: 1,
+            nether: false,
+            lid: &|_| 0.0,
+            sign: &|_| None,
+            banner: &|_| Vec::new(),
+            skull: &|_| None,
+            glyph: &glyph,
+            glyphs: 0,
+            dynamic_visible: None,
+        };
+        sign_text_calls(&scene, data, &data.front, Mat4::IDENTITY, 0, near)
+            .into_iter()
+            .map(|c| (c.text, c.x, c.y, c.color, c.outline))
+            .collect()
+    }
+    fn sign_with(lines: [Tag; 4]) -> SignData {
+        let mut data = SignData::default();
+        data.decode(&Tag::compound([(
+            "front_text",
+            Tag::compound([("messages", Tag::List(lines.to_vec()))]),
+        )]));
+        data
+    }
+    fn colored(text: &str, color: &str) -> Tag {
+        Tag::compound([
+            ("text", Tag::String(text.into())),
+            ("color", Tag::String(color.into())),
+        ])
+    }
+
+    /// `Font.StringRenderOutput`: a glyph takes its style's colour and the
+    /// sign's dark text colour only when the style has none (#9783). A line
+    /// of two colours is two calls, the second where the first ends, the
+    /// whole line centred.
+    #[test]
+    fn sign_text_takes_each_lines_own_colors() {
+        let mut two = colored("ab", "red");
+        let Tag::Compound(parts) = &mut two else {
+            unreachable!()
+        };
+        parts.insert("extra".into(), Tag::List(vec![colored("cd", "blue")]));
+        let data = sign_with([
+            Tag::String("plain".into()),
+            colored("Online", "green"),
+            two,
+            Tag::String("".into()),
+        ]);
+        // Black dye: the dark text colour is black. Sign lines are 10 apart
+        // from 20 above the middle.
+        assert_eq!(
+            front_calls(&data, false),
+            [
+                ("plain".to_owned(), -15.0, -20.0, 0xFF00_0000, 0),
+                ("Online".to_owned(), -18.0, -10.0, 0xFF55_FF55, 0),
+                ("ab".to_owned(), -12.0, 0.0, 0xFFFF_5555, 0),
+                ("cd".to_owned(), 0.0, 0.0, 0xFF55_55FF, 0),
+                (String::new(), 0.0, 10.0, 0xFF00_0000, 0),
+            ]
+        );
+    }
+
+    /// A glowing sign's own colour still wins over its dye, and the outline
+    /// stays the dye's dark colour. `§` codes in a line colour it too, and
+    /// `§r` goes back to the sign's colour.
+    #[test]
+    fn glowing_sign_text_keeps_its_outline_under_a_lines_own_colors() {
+        let mut data = sign_with([
+            Tag::String("plain".into()),
+            colored("Online", "green"),
+            Tag::String("§cRed§rX".into()),
+            Tag::String("".into()),
+        ]);
+        data.front.color = 14;
+        data.front.glowing = true;
+        let (red, outline) = (0xFFFF_0000, 0xFF66_0000);
+        assert_eq!(
+            front_calls(&data, true),
+            [
+                ("plain".to_owned(), -15.0, -20.0, red, outline),
+                ("Online".to_owned(), -18.0, -10.0, 0xFF55_FF55, outline),
+                ("Red".to_owned(), -12.0, 0.0, 0xFFFF_5555, outline),
+                ("X".to_owned(), 6.0, 0.0, red, outline),
+                (String::new(), 0.0, 10.0, red, outline),
+            ]
+        );
+    }
+
+    /// The text that fits the sign is drawn, in the colour it had.
+    #[test]
+    fn a_long_colored_line_is_cut_where_it_stops_fitting() {
+        // 90 wide: fifteen glyphs of 6.
+        let data = sign_with([
+            colored("abcdefghijklmnopqrst", "gold"),
+            Tag::String("".into()),
+            Tag::String("".into()),
+            Tag::String("".into()),
+        ]);
+        assert_eq!(
+            front_calls(&data, false)[0],
+            ("abcdefghijklmno".to_owned(), -45.0, -20.0, 0xFFFF_AA00, 0)
+        );
+    }
+
    #[test]
    fn cached_sign_text_matches_and_follows_changes() {
        let renderer = BlockEntityRenderer {
@@ -3835,6 +4219,7 @@ mod tests {
            skull: &|_| None,
            glyph: &glyph,
            glyphs: 0,
+            dynamic_visible: None,
        };
        let check = |scene: &Scene, pos: [i32; 3], state: u32| {
            let mut cached = Vec::new();
@@ -3894,6 +4279,23 @@ mod tests {
    /// submits the unit cube's two Y faces. Both are wound outward, so of each
    /// face only the side looking at the camera draws: the portal shows one
    /// surface from above and one from below, never both at once.
+    /// `RenderPipelines.BEACON_BEAM_OPAQUE` / `_TRANSLUCENT` keep the default
+    /// back-face culling, so a camera inside a beam sees no wall of it.
+    #[test]
+    fn beacon_beam_faces_cull_their_backs() {
+        let rect = Rect {
+            u0: 0.0,
+            v0: 0.0,
+            u1: 1.0,
+            v1: 1.0,
+            w: 16,
+            h: 16,
+        };
+        let mut out = Vec::new();
+        beacon_beam(Vec3::ZERO, &[(0xFFFFFF, 4)], 0.0, 1.0, rect, &mut out);
+        assert_eq!(out.len(), 32, "solid and glow, four quads each");
+        assert!(out.iter().all(|v| v.normal == CULL_BACK));
+    }
    #[test]
    fn the_end_portal_cube_is_one_sided() {
        let mut out = Vec::new();
@@ -3975,6 +4377,7 @@ mod tests {
            skull: &|_| None,
            glyph: &|_| Glyph::default(),
            glyphs: 0,
+            dynamic_visible: None,
        };
        let mut verts = Vec::new();
        renderer.render_block(&scene, [0; 3], state.0, Mat4::IDENTITY, 0xff, &mut verts);
@@ -4060,6 +4463,7 @@ mod tests {
            skull: &|_| None,
            glyph: &|_| Glyph::default(),
            glyphs: 0,
+            dynamic_visible: None,
        };
        // A closed single chest of `block` drawn by `renderer`: positions and UVs.
        let draw = |renderer: &BlockEntityRenderer, block: &str, texture: &'static str| {
@@ -358,6 +358,7 @@ fn batched_callbacks_preserve_entity_ranges_and_allow_immediate_culling() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    // Reverse local-position order to check that cache indexing does not
    // change the order of emitted entities.
@@ -446,6 +447,7 @@ fn static_cache_qualifies_local_positions_by_section_and_drops_old_entries() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let options = CacheOptions {
        shulker_boxes: true,
@@ -500,6 +502,7 @@ fn gpu_static_cache_uses_section_local_chests_and_keeps_visibility_separate() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let blocks = [([100, 70, -32], 0)];
    let other_block = [([116, 70, -32], 0)];
@@ -686,6 +689,7 @@ fn sign_text_cache_can_be_disabled_and_reenabled_without_changing_output() {
        skull: &|_| None,
        glyph: &glyph,
        glyphs: 0,
+        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
    let enabled = CacheOptions {
@@ -739,6 +743,7 @@ fn shulker_cache_tracks_settled_poses_and_does_not_freeze_opening_animation() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
    let options = CacheOptions {
@@ -840,6 +845,7 @@ fn shulker_cache_covers_all_colors_and_facing_directions() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let options = CacheOptions {
        shulker_boxes: true,
@@ -894,6 +900,7 @@ fn cached_bells_keep_shaking_until_the_animation_ends() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
    let options = CacheOptions {
@@ -955,6 +962,7 @@ fn cached_closed_chests_match_the_direct_model_and_rebuild_when_opening() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
    let options = CacheOptions {
@@ -1050,6 +1058,7 @@ fn closed_chest_cache_covers_all_materials_and_atlas_reloads() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let pos = [0, 64, 0];
    let options = CacheOptions {
@@ -1138,6 +1147,7 @@ fn double_chest_cache_bypasses_both_halves_while_either_lid_is_open() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let pair = [([0, 64, 0], 0), ([1, 64, 0], 1)];
    let options = CacheOptions {
@@ -1213,6 +1223,7 @@ fn decorated_pot_cache_tracks_sherds_and_bypasses_wobble_animation() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
    let options = CacheOptions {
@@ -1291,6 +1302,7 @@ fn banner_cache_keeps_the_pole_static_while_the_flag_and_patterns_update() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
    let options = CacheOptions {
@@ -1357,6 +1369,7 @@ fn cached_wall_banner_poles_use_the_wall_model() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let pos = [0, 64, 0];
    let options = CacheOptions {
@@ -1404,6 +1417,7 @@ fn copper_statue_cache_rebuilds_when_its_pose_state_changes() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let options = CacheOptions {
        copper_golem_statues: true,
@@ -1509,6 +1523,7 @@ fn copper_statue_cache_covers_weathering_waxing_and_all_poses() {
        skull: &|_| None,
        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let options = CacheOptions {
        copper_golem_statues: true,
@@ -90,9 +90,20 @@ pub fn effect_lines<'a>(
                );
            }
            let instant = effect(e).is_some_and(|d| d.instant);
-            let scaled = (duration as f32 * scale) as i32;
-            if !instant && scaled > 20 {
-                line = format!("{line} ({})", format_duration(scaled));
+            if !instant {
+                if duration == -1 {
+                    // MobEffectInstance.isInfiniteDuration: formatDuration says
+                    // the infinite sign, not a time.
+                    line = format!(
+                        "{line} ({})",
+                        translate("effect.duration.infinite").unwrap_or_else(|| "∞".to_owned())
+                    );
+                } else {
+                    let scaled = (duration as f32 * scale) as i32;
+                    if scaled > 20 {
+                        line = format!("{line} ({})", format_duration(scaled));
+                    }
+                }
            }
            (line, effect(e).map_or(Category::Neutral, |d| d.category))
        })
@@ -340,6 +351,17 @@ impl BrewingStand {
        }
        out
    }
+    pub fn idle(&self) -> bool {
+        let bottles = [
+            self.items[0].is_some(),
+            self.items[1].is_some(),
+            self.items[2].is_some(),
+        ];
+        self.brew_time <= 0
+            && self.items[3].is_none()
+            && (self.fuel > 0 || self.items[4].is_none())
+            && self.last_bottles == Some(bottles)
+    }
    fn brew(&mut self, brewing: &Brewing, items: &Items, out: &mut BrewTick) {
        let Some(ingredient) = self.items[3].clone() else {
            return;
@@ -455,6 +477,84 @@ mod tests {
        assert_eq!(stand.brew_time, 0);
    }

+    #[test]
+    fn a_brewing_stand_is_idle_only_while_its_tick_changes_nothing() {
+        let mut stand = BrewingStand::new();
+        assert!(!stand.idle());
+        stand.last_bottles = Some([false; 3]);
+        assert!(stand.idle());
+        stand.items[0] = Some(ItemStack::new("minecraft:potion", 1));
+        assert!(!stand.idle());
+        stand.last_bottles = Some([true, false, false]);
+        assert!(stand.idle());
+        stand.items[4] = Some(ItemStack::new("minecraft:blaze_powder", 1));
+        assert!(!stand.idle());
+        stand.fuel = 3;
+        assert!(stand.idle());
+        stand.items[3] = Some(ItemStack::new("minecraft:nether_wart", 1));
+        assert!(!stand.idle());
+        stand.items[3] = None;
+        stand.brew_time = 5;
+        assert!(!stand.idle());
+    }
+
+    /// The stand sleeps while `idle`, so its tick must change nothing then: run the real
+    /// tick on idle stands and compare, and check a stand with fuel to take wakes.
+    #[test]
+    fn an_idle_brewing_stand_tick_changes_nothing() {
+        let items = Items::for_tests(std::collections::HashMap::new());
+        let brewing = Brewing {
+            reagents: ["minecraft:nether_wart".to_owned()].into_iter().collect(),
+            inputs: HashSet::new(),
+            recipes: vec![BrewingRecipe {
+                id: "awkward".into(),
+                input: PotionIngredient {
+                    items: ["minecraft:potion".to_owned()].into_iter().collect(),
+                    potions: Some(["minecraft:water".to_owned()].into_iter().collect()),
+                },
+                reagent: PotionIngredient {
+                    items: ["minecraft:nether_wart".to_owned()].into_iter().collect(),
+                    potions: None,
+                },
+                output: ItemStack::new("minecraft:potion", 1).with_potion("minecraft:awkward"),
+            }],
+        };
+        let providers = Providers::empty();
+        let water = || Some(ItemStack::new("minecraft:potion", 1).with_potion("minecraft:water"));
+        let stand = |bottle: bool, fuel: i32, powder: bool| {
+            let mut s = BrewingStand::new();
+            s.fuel = fuel;
+            if bottle {
+                s.items[1] = water();
+            }
+            if powder {
+                s.items[4] = Some(ItemStack::new("minecraft:blaze_powder", 1));
+            }
+            s.last_bottles = Some([false, bottle, false]);
+            s
+        };
+        for before in [
+            stand(false, 0, false),
+            stand(true, 0, false),
+            stand(true, 5, false),
+            stand(true, 5, true),
+        ] {
+            assert!(before.idle(), "{before:?}");
+            let mut after = before.clone();
+            assert_eq!(
+                after.tick(&brewing, &items, &providers),
+                BrewTick::default()
+            );
+            assert_eq!(format!("{after:?}"), format!("{before:?}"));
+        }
+        // A brewable ingredient starts the brew: not idle, and the tick changes it.
+        let mut brewing_now = stand(true, 5, false);
+        brewing_now.items[3] = Some(ItemStack::new("minecraft:nether_wart", 1));
+        assert!(!brewing_now.idle());
+        brewing_now.tick(&brewing, &items, &providers);
+        assert_eq!(brewing_now.brew_time, 400);
+    }
+
    /// #3312: `PotionContents.getPotionDescription` names the effects with
    /// translatable components, so a Russian game reads them from ru_ru.json
    /// (the prepared one; skipped without it), as the tooltip's other lines.
@@ -473,4 +573,15 @@ mod tests {
        assert!(lines[0].0.starts_with("Замедление IV ("), "{lines:?}");
        assert!(lines[1].0.starts_with("Сопротивление III ("), "{lines:?}");
    }
+
+    #[test]
+    fn infinite_effects_say_the_infinite_sign() {
+        // MobEffectInstance.isInfiniteDuration: a -1 duration says the
+        // infinite sign, not a time; a short one still says nothing.
+        let translate = |key: &str| (key == "effect.duration.infinite").then(|| "∞".to_owned());
+        let lines = effect_lines([("minecraft:resistance", -1, 0)], 1.0, &translate);
+        assert_eq!(lines[0].0, "resistance (∞)");
+        let lines = effect_lines([("minecraft:resistance", 15, 0)], 1.0, &translate);
+        assert_eq!(lines[0].0, "resistance");
+    }
 }
@@ -1,3 +1,27 @@
+// `joml::Mat4::rotation`, `rotate_affine`, `transform_affine` and `invert_orthonormal`, and
+// `joml::Quat::rotation_x`/`_y`/`_z`, in this file are adapted from JOML 1.10.9's `Matrix4f`,
+// `Quaternionf` and `Vector4f` (https://github.com/JOML-CI/JOML, MIT; see THIRD_PARTY_NOTICES.md).
+//
+// Copyright (c) 2015-2026 Richard Greenlees
+//
+// 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.
+
 //! The camera (`Camera.tick`, `tickFov`, `calculateFov`, `alignWithEntity`,
 //! `getMaxZoom`, `setRotation`, `move`), view and hurt bobbing
 //! (`GameRenderer.bobView`, `bobHurt`), the walk and bob history they read
@@ -119,6 +143,40 @@ pub mod joml {
                w: w * cz + z * sz,
            }
        }
+        /// `Quaternionf.rotationX(angle)`.
+        pub fn rotation_x(angle: f32) -> Self {
+            let (x, w) = Self::half_turn(angle);
+            Self {
+                x,
+                y: 0.0,
+                z: 0.0,
+                w,
+            }
+        }
+        /// `Quaternionf.rotationY(angle)`.
+        pub fn rotation_y(angle: f32) -> Self {
+            let (y, w) = Self::half_turn(angle);
+            Self {
+                x: 0.0,
+                y,
+                z: 0.0,
+                w,
+            }
+        }
+        /// `Quaternionf.rotationZ(angle)`.
+        pub fn rotation_z(angle: f32) -> Self {
+            let (z, w) = Self::half_turn(angle);
+            Self {
+                x: 0.0,
+                y: 0.0,
+                z,
+                w,
+            }
+        }
+        fn half_turn(angle: f32) -> (f32, f32) {
+            let sin = sin(angle * 0.5);
+            (sin, cos_from_sin(sin, angle * 0.5))
+        }
        /// `Quaternionf.transform(x, y, z, dest)` (`Vector3f.rotate`).
        pub fn transform(&self, v: [f32; 3]) -> [f32; 3] {
            let [x, y, z] = v;
@@ -142,8 +200,10 @@ pub mod joml {
    }

    const PERSPECTIVE: u8 = 1;
+    const AFFINE: u8 = 2;
    const IDENTITY: u8 = 4;
    const TRANSLATION: u8 = 8;
+    const ORTHONORMAL: u8 = 16;

    /// A JOML `Matrix4f` with its property flags, which select the code
    /// paths (and so the rounding) of later operations. `m[column * 4 + row]`.
@@ -284,10 +344,149 @@ pub mod joml {
            // already taken that branch.
            self.rotate_axis(2, ang);
        }
+        /// `Matrix4f.rotation(Quaternionfc)`.
+        pub fn rotation(&mut self, q: Quat) {
+            let (w2, x2, y2, z2) = (q.w * q.w, q.x * q.x, q.y * q.y, q.z * q.z);
+            let zw = q.z * q.w;
+            let dzw = zw + zw;
+            let xy = q.x * q.y;
+            let dxy = xy + xy;
+            let xz = q.x * q.z;
+            let dxz = xz + xz;
+            let yw = q.y * q.w;
+            let dyw = yw + yw;
+            let yz = q.y * q.z;
+            let dyz = yz + yz;
+            let xw = q.x * q.w;
+            let dxw = xw + xw;
+            self.reset_unless_identity();
+            self.set(0, 0, w2 + x2 - z2 - y2);
+            self.set(0, 1, dxy + dzw);
+            self.set(0, 2, dxz - dyw);
+            self.set(1, 0, -dzw + dxy);
+            self.set(1, 1, y2 - z2 + w2 - x2);
+            self.set(1, 2, dyz + dxw);
+            self.set(2, 0, dyw + dxz);
+            self.set(2, 1, dyz - dxw);
+            self.set(2, 2, z2 - y2 - x2 + w2);
+            self.properties = AFFINE | ORTHONORMAL;
+        }
+        /// An affine matrix of no more specific kind, as JOML's property flags have it.
+        pub fn affine(m: glam::Mat4) -> Self {
+            Self {
+                m: m.to_cols_array(),
+                properties: AFFINE,
+            }
+        }
+        /// `Matrix4f.rotate(Quaternionfc)` of an affine matrix that is neither the identity nor
+        /// a pure translation (`rotateAffine`).
+        pub fn rotate_affine(&mut self, q: Quat) {
+            debug_assert!(
+                self.properties & AFFINE != 0 && self.properties & (IDENTITY | TRANSLATION) == 0
+            );
+            let (w2, x2, y2, z2) = (q.w * q.w, q.x * q.x, q.y * q.y, q.z * q.z);
+            let zw = q.z * q.w;
+            let dzw = zw + zw;
+            let xy = q.x * q.y;
+            let dxy = xy + xy;
+            let xz = q.x * q.z;
+            let dxz = xz + xz;
+            let yw = q.y * q.w;
+            let dyw = yw + yw;
+            let yz = q.y * q.z;
+            let dyz = yz + yz;
+            let xw = q.x * q.w;
+            let dxw = xw + xw;
+            let r = [
+                [w2 + x2 - z2 - y2, dxy + dzw, dxz - dyw],
+                [-dzw + dxy, y2 - z2 + w2 - x2, dyz + dxw],
+                [dyw + dxz, dyz - dxw, z2 - y2 - x2 + w2],
+            ];
+            let s = *self;
+            for (column, r) in r.iter().enumerate() {
+                for row in 0..3 {
+                    let v = s.get(0, row) * r[0] + s.get(1, row) * r[1] + s.get(2, row) * r[2];
+                    self.set(column, row, v);
+                }
+                self.set(column, 3, 0.0);
+            }
+            self.properties &= !(PERSPECTIVE | IDENTITY | TRANSLATION);
+        }
+        /// `Vector4f.mul(Matrix4fc)` of an affine matrix (`mulAffine`, JOML's `Math.fma`
+        /// unfused): the matrix times `v`, `w` kept.
+        pub fn transform_affine(&self, v: [f32; 4]) -> [f32; 3] {
+            debug_assert!(self.properties & AFFINE != 0);
+            let [x, y, z, w] = v;
+            std::array::from_fn(|row| {
+                self.get(0, row) * x
+                    + (self.get(1, row) * y + (self.get(2, row) * z + self.get(3, row) * w))
+            })
+        }
+        /// `Matrix4f.invert()` of a rotation and translation (`invertOrthonormal`; with the
+        /// identity and pure-translation shortcuts). `None` for any other matrix, which JOML
+        /// inverts by other code paths.
+        pub fn invert_orthonormal(&self) -> Option<Self> {
+            if self.properties & IDENTITY != 0 {
+                return Some(Self::IDENTITY);
+            }
+            let mut out = *self;
+            if self.properties & TRANSLATION != 0 {
+                for row in 0..3 {
+                    out.set(3, row, -self.get(3, row));
+                }
+                out.properties = AFFINE | TRANSLATION | ORTHONORMAL;
+                return Some(out);
+            }
+            if self.properties & ORTHONORMAL == 0 {
+                return None;
+            }
+            let g = |c, r| self.get(c, r);
+            let t = |c| -(g(c, 0) * g(3, 0) + g(c, 1) * g(3, 1) + g(c, 2) * g(3, 2));
+            out.m = [
+                g(0, 0),
+                g(1, 0),
+                g(2, 0),
+                0.0,
+                g(0, 1),
+                g(1, 1),
+                g(2, 1),
+                0.0,
+                g(0, 2),
+                g(1, 2),
+                g(2, 2),
+                0.0,
+                t(0),
+                t(1),
+                t(2),
+                1.0,
+            ];
+            out.properties = AFFINE | ORTHONORMAL;
+            Some(out)
+        }
+        pub fn to_glam(self) -> glam::Mat4 {
+            glam::Mat4::from_cols_array(&self.m)
+        }
    }
 }
 use joml::{Mat4, Quat};

+/// `Camera.getViewRotationMatrix` to the last bit: `Matrix4f.rotation` of the conjugate of
+/// `setRotation`'s quaternion, and its JOML `invert()`. `view_matrix` turns the same quaternion
+/// into a matrix by glam's formula, which differs in the last bits (1.0 for 0.99999994, 6e-8 for
+/// 0).
+pub fn view_rotation_matrix(yaw: f32, pitch: f32) -> (glam::Mat4, glam::Mat4) {
+    let q = Quat::rotation_yxz(PI - yaw * DEG_TO_RAD, -pitch * DEG_TO_RAD, 0.0);
+    let mut m = Mat4::IDENTITY;
+    m.rotation(Quat {
+        x: -q.x,
+        y: -q.y,
+        z: -q.z,
+        w: q.w,
+    });
+    let inverse = m.invert_orthonormal().expect("a rotation is orthonormal");
+    (m.to_glam(), inverse.to_glam())
+}
+
 /// Camera-relative world view used by terrain, sky and the first-person hand.
 pub fn view_matrix(yaw: f32, pitch: f32) -> glam::Mat4 {
    // Vanilla uses the conjugate of Camera.rotation, not a world-up look-at.
@@ -174,6 +174,12 @@ impl ChatOptions {
 #[derive(Clone, Debug)]
 struct Message {
    added: u64,
+    /// Local hour and minute it came in (PvP & HUD's chat timestamps).
+    time: (u8, u8),
+    /// How many times in a row it came (PvP & HUD's compact chat), 1 for once.
+    repeats: u32,
+    /// The lines it wrapped to the last time it was laid out (0 while hidden).
+    wrapped: usize,
    content: Text,
    tag: Option<std::sync::Arc<Tag>>,
    source: ChatSource,
@@ -186,6 +192,32 @@ struct Line {
    added: u64,
    content: Text,
    tag: Option<std::sync::Arc<Tag>>,
+    /// The whole message's text, for PvP & HUD's copy on click.
+    message: std::sync::Arc<str>,
+}
+
+/// PvP & HUD's chat options (`pvp::ChatQol`): each changes the lines, so a change rewraps them.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ChatQol {
+    /// Each message starts with the local time it came in.
+    pub timestamps: bool,
+    /// A message equal to the one before it raises that one's count ("(x3)") instead of adding lines.
+    pub compact: bool,
+}
+/// Whether `next` repeats `last`: the same text, kind and tag, neither one signed (a server may
+/// delete a signed message by itself).
+fn repeats(last: &Message, next: &Message) -> bool {
+    last.signature.is_none()
+        && next.signature.is_none()
+        && last.source == next.source
+        && last.tag == next.tag
+        && last.content == next.content
+}
+/// The local hour and minute.
+fn local_time() -> (u8, u8) {
+    use chrono::Timelike;
+    let now = chrono::Local::now();
+    (now.hour() as u8, now.minute() as u8)
 }

 /// `GuiMessageTag`: the bar at the left of a message's lines, the tooltip
@@ -270,6 +302,14 @@ pub struct Chat {
    /// `ChatComponent.messageDeletionQueue`: deletions of messages still
    /// too new to replace, with the tick from which they may be.
    deletions: Vec<(Box<Signature>, u64)>,
+    qol: ChatQol,
+    /// PvP & HUD's chat search is on: the screen shows its prompt.
+    pub search_prompt: bool,
+    /// PvP & HUD's chat search: only messages holding this (lower case) show.
+    search: Option<String>,
+    /// The tests' clock in place of the local time.
+    #[cfg(test)]
+    clock: Option<(u8, u8)>,
 }
 impl Chat {
    pub fn lines_per_page(&self, focused: bool) -> usize {
@@ -331,6 +371,9 @@ impl Chat {
            font,
            Message {
                added: ticks,
+                time: (0, 0),
+                repeats: 1,
+                wrapped: 0,
                content,
                tag: tag.map(std::sync::Arc::new),
                source: ChatSource::Player,
@@ -352,6 +395,9 @@ impl Chat {
            font,
            Message {
                added: ticks,
+                time: (0, 0),
+                repeats: 1,
+                wrapped: 0,
                content,
                tag,
                source,
@@ -360,7 +406,7 @@ impl Chat {
            focused,
        );
    }
-    fn push_message(&mut self, font: &crate::font::Font, message: Message, focused: bool) {
+    fn push_message(&mut self, font: &crate::font::Font, mut message: Message, focused: bool) {
        if !self.abilities.shows(message.source) {
            return;
        }
@@ -370,12 +416,52 @@ impl Chat {
        if self.log {
            println!("[CHAT] {plain}");
        }
-        self.add_lines(font, &message, focused);
+        message.time = self.now();
+        self.received += 1;
+        if self.qol.compact
+            && let Some(last) = self.messages.first()
+            && repeats(last, &message)
+        {
+            // The newest lines are that message's: they make way for its lines with the count.
+            let mut last = self.messages.remove(0);
+            let shown = last.wrapped.min(self.lines.len());
+            self.lines.drain(..shown);
+            // A reader scrolled up keeps their view: only lines the merge adds move it.
+            let (scroll, new_since_scroll) = (self.scroll, self.new_since_scroll);
+            last.repeats += 1;
+            last.added = message.added;
+            last.time = message.time;
+            last.wrapped = self.add_lines(font, &last, focused);
+            if scroll > 0 {
+                self.scroll = scroll;
+                self.new_since_scroll = new_since_scroll;
+                self.scroll_by(last.wrapped as i32 - shown as i32, focused);
+            }
+            self.messages.insert(0, last);
+            return;
+        }
+        message.wrapped = self.add_lines(font, &message, focused);
        self.messages.insert(0, message);
        self.messages.truncate(100);
-        self.received += 1;
    }
-    fn add_lines(&mut self, font: &crate::font::Font, message: &Message, focused: bool) {
+    fn now(&self) -> (u8, u8) {
+        #[cfg(test)]
+        if let Some(time) = self.clock {
+            return time;
+        }
+        local_time()
+    }
+    /// The lines `message` wraps to (none when the chat search hides it), added newest first.
+    fn add_lines(&mut self, font: &crate::font::Font, message: &Message, focused: bool) -> usize {
+        // What the chat shows: legacy `§` codes format the text, they aren't part of it.
+        let whole = message.content.strip_legacy().plain();
+        if let Some(query) = &self.search
+            && !whole.to_lowercase().contains(query.as_str())
+        {
+            return 0;
+        }
+        let whole: std::sync::Arc<str> = whole.into();
+        let mut count = 0;
        // GuiMessage.splitLines: room for the tag's icon (its width, 4 before and 2 after).
        let icon = if message.tag.as_ref().is_some_and(|tag| tag.icon) {
            9 + 4 + 2
@@ -383,8 +469,9 @@ impl Chat {
            0
        };
        let width = self.max_width() - icon;
-        let content = self.displayed(&message.content);
+        let content = self.message_text(message);
        for line in font.wrap_components(&content, width) {
+            count += 1;
            if focused && self.scroll > 0 {
                self.new_since_scroll = true;
                self.scroll_by(1, focused);
@@ -395,10 +482,12 @@ impl Chat {
                    added: message.added,
                    content: line,
                    tag: message.tag.clone(),
+                    message: whole.clone(),
                },
            );
        }
        self.lines.truncate(100);
+        count
    }
    /// What a message's lines wrap (ComponentRenderUtils.wrapComponents):
    /// without Chat Colors its `§` codes are stripped (stripColor); with
@@ -410,6 +499,67 @@ impl Chat {
            content.strip_legacy()
        }
    }
+    /// A message's lines before wrapping: [`Chat::displayed`], with PvP & HUD's time before it
+    /// and count after it, in grey.
+    fn message_text(&self, message: &Message) -> Text {
+        let content = self.displayed(&message.content);
+        if !self.qol.timestamps && message.repeats <= 1 {
+            return content;
+        }
+        let mut out = Text::empty();
+        if self.qol.timestamps {
+            let (h, m) = message.time;
+            let time = Text::literal(format!("{h:02}:{m:02}"));
+            out = out.append(
+                Text::translate_with_fallback("horizon.chat.timestamp", "[%s] ", &[time])
+                    .with_color(text::GRAY),
+            );
+        }
+        out = out.append(content);
+        if message.repeats > 1 {
+            let count = Text::literal(message.repeats.to_string());
+            out = out.append(
+                Text::translate_with_fallback("horizon.chat.repeats", " (x%s)", &[count])
+                    .with_color(text::GRAY),
+            );
+        }
+        out
+    }
+    /// PvP & HUD's chat options; a change lays the lines out again.
+    pub fn set_qol(&mut self, atlas: &HudAtlas, qol: ChatQol) {
+        if self.qol != qol {
+            self.qol = qol;
+            self.rewrap(&atlas.font);
+        }
+    }
+    /// PvP & HUD's chat search: only the messages holding `query` (any case) show; `None` or
+    /// an empty query shows them all again.
+    pub fn set_search(&mut self, atlas: &HudAtlas, query: Option<&str>) {
+        self.set_search_with(&atlas.font, query);
+    }
+    fn set_search_with(&mut self, font: &crate::font::Font, query: Option<&str>) {
+        // Called each frame while searching: no work (nor allocation) for the same query.
+        let blank = |q: &str| q.trim().is_empty();
+        let same = match (&self.search, query) {
+            (None, None) => true,
+            (None, Some(q)) => blank(q),
+            (Some(_), None) => false,
+            (Some(current), Some(q)) => q.chars().flat_map(char::to_lowercase).eq(current.chars()),
+        };
+        if same {
+            return;
+        }
+        let query = query
+            .map(str::to_lowercase)
+            .filter(|q| !q.trim().is_empty());
+        if self.search != query {
+            self.search = query;
+            self.rewrap(font);
+        }
+    }
+    pub fn searching(&self) -> bool {
+        self.search.is_some()
+    }
    /// Re-wrap after a width or scale change (ChatComponent.rescaleChat),
    /// keeping only the messages the Chat option shows.
    pub fn rescale(&mut self, atlas: &HudAtlas) {
@@ -419,16 +569,15 @@ impl Chat {
        self.scroll = 0;
        self.new_since_scroll = false;
        self.lines.clear();
-        let messages: Vec<Message> = self
-            .messages
-            .iter()
-            .rev()
-            .filter(|m| self.abilities.shows(m.source))
-            .cloned()
-            .collect();
-        for m in &messages {
-            self.add_lines(font, m, false);
+        let mut messages = std::mem::take(&mut self.messages);
+        for m in messages.iter_mut().rev() {
+            m.wrapped = if self.abilities.shows(m.source) {
+                self.add_lines(font, m, false)
+            } else {
+                0
+            };
        }
+        self.messages = messages;
    }
    /// `ChatComponent.setVisibleMessageFilter`: the Chat option changed;
    /// the messages it now hides leave the chat, those it shows again return.
@@ -490,6 +639,9 @@ impl Chat {
        }
        *message = Message {
            added: message.added,
+            time: message.time,
+            repeats: 1,
+            wrapped: 0,
            content: Self::deleted_marker(),
            tag: Some(std::sync::Arc::new(Tag::system_single_player(
                SYSTEM_INDICATOR,
@@ -694,15 +846,42 @@ impl Chat {
    pub fn draw(&self, batch: &mut HudBatch, atlas: &HudAtlas, ticks: f32, focused: bool) {
        let draws = self.layout(batch.height as i32, ticks, focused);
        hud_layout::paint(batch, atlas, &draws);
-        if focused && self.abilities.any_restriction() {
+        let restricted = focused && self.abilities.any_restriction();
+        if restricted {
            let prompt = self.restricted_prompt(&atlas.font, batch.height as i32);
            hud_layout::paint(batch, atlas, &prompt);
        }
+        if focused && self.search_prompt {
+            let row = if restricted { 2 } else { 1 };
+            let prompt = self.search_prompt(&atlas.font, batch.height as i32, row);
+            hud_layout::paint(batch, atlas, &prompt);
+        }
    }
    /// `ChatComponent.extractRenderState` for `FOREGROUND_RESTRICTED`: a
    /// background row and the red, underlined "Chat is restricted" line in
    /// the row above the messages, clipped to the chat's width.
    fn restricted_prompt(&self, font: &crate::font::Font, height: i32) -> Vec<GuiDraw> {
+        let prompt = Text::translate("chat_screen.restricted", &[]).with_style(&Style {
+            color: Some(text::RED),
+            underlined: Some(true),
+            ..Style::default()
+        });
+        self.prompt_above(font, height, prompt, 1)
+    }
+    /// PvP & HUD's chat search: a yellow "Search chat:" line above the lines while the box holds
+    /// the query.
+    fn search_prompt(&self, font: &crate::font::Font, height: i32, row: i32) -> Vec<GuiDraw> {
+        let label = Text::translate_with_fallback("horizon.chat.search", "Search chat:", &[]);
+        self.prompt_above(font, height, label.with_color(text::YELLOW), row)
+    }
+    /// A line `row` lines above the shown ones, on the chat's background.
+    fn prompt_above(
+        &self,
+        font: &crate::font::Font,
+        height: i32,
+        prompt: Text,
+        row: i32,
+    ) -> Vec<GuiDraw> {
        let o = &self.options;
        let scale = o.scale as f32;
        let max_width = hud_layout::ceil(o.width_px() as f32 / scale);
@@ -715,12 +894,8 @@ impl Chat {
            .len()
            .saturating_sub(self.scroll)
            .min(self.lines_per_page(true));
-        let top = chat_bottom - (shown as i32 + 1) * entry_height;
-        let mut prompt = Text::translate("chat_screen.restricted", &[]).with_style(&Style {
-            color: Some(text::RED),
-            underlined: Some(true),
-            ..Style::default()
-        });
+        let top = chat_bottom - (shown as i32 + row) * entry_height;
+        let mut prompt = prompt;
        // ComponentRenderUtils.clipText.
        let mut width = 0.0;
        let fits = prompt
@@ -765,6 +940,12 @@ impl Chat {
    ) -> Option<ClickEvent> {
        self.style_at(font, height, x, y)?.click
    }
+    /// The whole text of the message under a GUI-space cursor while chat is focused (PvP &
+    /// HUD's copy on click), without its time or count.
+    pub fn message_at(&self, height: i32, x: f64, y: f64) -> Option<&str> {
+        let (line, x) = self.line_at(height, x, y)?;
+        (x >= 0.0).then_some(&*line.message)
+    }
    /// The hover text under a GUI-space cursor while chat is focused
    /// (ChatScreen.render's `renderComponentHoverEffect`).
    pub fn hover_at(&self, font: &crate::font::Font, height: i32, x: f64, y: f64) -> Option<Text> {
@@ -34,6 +34,7 @@ fn add(chat: &mut Chat, font: &Font, content: Text) {
                added: 0,
                content,
                tag: None,
+                message: "".into(),
            },
        );
    }
@@ -51,6 +52,7 @@ fn smooth_chat_slides_a_line_in_and_can_hide_the_indicator() {
        tag: Some(std::sync::Arc::new(Tag::system_single_player(
            SYSTEM_INDICATOR,
        ))),
+        message: "hi".into(),
    });
    let text_alpha = |draws: &[GuiDraw]| {
        draws.iter().find_map(|d| match d {
@@ -701,3 +703,140 @@ fn a_chat_message_is_cut_to_the_256_utf16_units_the_packet_holds() {
    let mixed = format!("{}\u{1f600}", "b".repeat(255));
    assert_eq!(normalize_chat_message(&mixed), "b".repeat(255));
 }
+
+/// PvP & HUD's chat options: the time before each message, and a repeated message counted on
+/// its own lines instead of filling the chat.
+#[test]
+fn timestamps_and_compact_chat_change_the_lines_not_the_messages() {
+    let font = font();
+    let mut chat = Chat {
+        clock: Some((9, 5)),
+        ..Chat::default()
+    };
+    chat.qol.compact = true;
+    let says = |chat: &mut Chat, text: &str| {
+        chat.add_message(
+            &font,
+            Text::literal(text),
+            None,
+            ChatSource::Server,
+            0,
+            false,
+        );
+    };
+    let shown =
+        |chat: &Chat| -> Vec<String> { chat.lines.iter().map(|l| l.content.plain()).collect() };
+    says(&mut chat, "gg");
+    says(&mut chat, "gg");
+    says(&mut chat, "gg");
+    assert_eq!(shown(&chat), ["gg (x3)"]);
+    says(&mut chat, "wp");
+    says(&mut chat, "gg");
+    assert_eq!(shown(&chat), ["gg", "wp", "gg (x3)"]);
+    assert_eq!(chat.received, 5, "every message still counts as received");
+    chat.qol.timestamps = true;
+    chat.rewrap(&font);
+    assert_eq!(
+        shown(&chat),
+        ["[09:05] gg", "[09:05] wp", "[09:05] gg (x3)"]
+    );
+    // Copying takes the message as it came: no time, no count.
+    assert_eq!(&*chat.lines[2].message, "gg");
+    // Turned off, the history shows each repeat as it was counted.
+    chat.qol = ChatQol::default();
+    chat.rewrap(&font);
+    assert_eq!(shown(&chat), ["gg", "wp", "gg (x3)"]);
+}
+
+/// PvP & HUD's chat search: only the messages holding the query show, in any case; clearing
+/// it brings every line back.
+#[test]
+fn the_chat_search_keeps_the_matching_messages() {
+    let font = font();
+    let mut chat = Chat::default();
+    for text in ["Alpha one", "beta", "ALPHABET soup"] {
+        chat.add_message(
+            &font,
+            Text::literal(text),
+            None,
+            ChatSource::Server,
+            0,
+            false,
+        );
+    }
+    let shown =
+        |chat: &Chat| -> Vec<String> { chat.lines.iter().map(|l| l.content.plain()).collect() };
+    chat.set_search_with(&font, Some("alpha"));
+    assert!(chat.searching());
+    assert_eq!(shown(&chat), ["ALPHABET soup", "Alpha one"]);
+    // A new message that doesn't match stays out of sight until the search ends.
+    chat.add_message(
+        &font,
+        Text::literal("gamma"),
+        None,
+        ChatSource::Server,
+        0,
+        false,
+    );
+    assert_eq!(shown(&chat).len(), 2);
+    chat.set_search_with(&font, Some("  "));
+    assert!(!chat.searching());
+    assert_eq!(
+        shown(&chat),
+        ["gamma", "ALPHABET soup", "beta", "Alpha one"]
+    );
+}
+
+/// Search and copy read a message as the chat shows it: legacy `§` codes format it, they
+/// aren't text.
+#[test]
+fn the_chat_search_and_copy_skip_legacy_codes() {
+    let font = font();
+    let mut chat = Chat::default();
+    for text in ["He§cllo", "§aplain"] {
+        chat.add_message(
+            &font,
+            Text::literal(text),
+            None,
+            ChatSource::Server,
+            0,
+            false,
+        );
+    }
+    assert_eq!(&*chat.lines[1].message, "Hello");
+    chat.set_search_with(&font, Some("hello"));
+    assert_eq!(chat.lines.len(), 1);
+    // `c` and `a` are codes here, not letters of either message.
+    chat.set_search_with(&font, Some("c"));
+    assert_eq!(chat.lines.len(), 0);
+}
+
+/// A repeat merged by compact chat leaves a reader scrolled up where they were.
+#[test]
+fn a_compact_repeat_keeps_the_scrolled_view_still() {
+    let font = font();
+    let mut chat = Chat::default();
+    chat.qol.compact = true;
+    let says = |chat: &mut Chat, text: &str| {
+        chat.add_message(
+            &font,
+            Text::literal(text),
+            None,
+            ChatSource::Server,
+            0,
+            true,
+        );
+    };
+    for i in 0..60 {
+        says(&mut chat, &format!("line {i}"));
+    }
+    says(&mut chat, "gg");
+    chat.scroll_by(5, true);
+    assert_eq!(chat.scroll, 5);
+    says(&mut chat, "gg");
+    assert_eq!(chat.lines[0].content.plain(), "gg (x2)");
+    assert_eq!(chat.scroll, 5);
+    // A new message still pushes the view up by its line.
+    says(&mut chat, "new");
+    assert_eq!(chat.scroll, 6);
+}
@@ -225,6 +225,8 @@ pub const BIOME_STRATEGY: Strategy = Strategy::biomes(8);
 /// (what vanilla servers and clients send), more when content mods add states
 /// past 65,536 (docs/modpacks.md). Set once, before the first chunk.
 static BLOCK_BITS: std::sync::atomic::AtomicU8 = std::sync::atomic::AtomicU8::new(16);
+/// States in the registry, set with [`BLOCK_BITS`].
+static BLOCK_STATES: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(u32::MAX);

 /// Block states are `PalettedContainer`s over the registry: vanilla's 16-bit
 /// global palette, wider with enough content mods.
@@ -232,6 +234,35 @@ pub fn block_strategy() -> Strategy {
    Strategy::blocks(BLOCK_BITS.load(std::sync::atomic::Ordering::Relaxed))
 }

+/// Whether the registry has this state. Every id is known until the registry is loaded.
+pub fn known_block_state(id: u32) -> bool {
+    id < BLOCK_STATES.load(std::sync::atomic::Ordering::Relaxed)
+}
+
+/// A server's block container in our palette width. Ids past our registry (a
+/// server or host with mods we lack) read as air: every per-state table is
+/// indexed by them, and a palette's unused entries are scanned too.
+pub fn known_blocks_only(blocks: PalettedContainer) -> PalettedContainer {
+    let ours = block_strategy();
+    let unknown = |id: u32| !known_block_state(id) || u64::from(id) >> ours.global_bits != 0;
+    let any_unknown = if blocks.is_global() {
+        blocks.has(unknown)
+    } else {
+        blocks.maybe_has(unknown)
+    };
+    if !any_unknown && blocks.strategy().global_bits == ours.global_bits {
+        return blocks;
+    }
+    let mut values = [0u32; 4096];
+    blocks.unpack(&mut values);
+    for value in &mut values {
+        if unknown(*value) {
+            *value = 0;
+        }
+    }
+    PalettedContainer::from_values(ours, &values)
+}
+
 /// Frees `columns` (`count` of them) on a short-lived thread of its own
 /// when there are many: a teleport or a dimension change drops a few
 /// thousand columns at once, and freeing their sections took the frame
@@ -250,6 +281,10 @@ pub fn free_columns<T: Send + 'static>(columns: T, count: usize) {
 pub fn set_block_states(states: usize) {
    let bits = horizon_core::paletted::ceil_log2(states).max(16);
    BLOCK_BITS.store(bits, std::sync::atomic::Ordering::Relaxed);
+    BLOCK_STATES.store(
+        u32::try_from(states).unwrap_or(u32::MAX),
+        std::sync::atomic::Ordering::Relaxed,
+    );
    forget_shared();
 }

@@ -431,6 +431,16 @@ pub struct SignText {
    pub glowing: bool,
    /// The `click_event` in each line's component style, as saved.
    pub click: [Option<Tag>; 4],
+    /// Each line's saved component when it is more than plain text (a colour,
+    /// siblings, a list), so its style survives loading, saving and the
+    /// network. See `SignText::message` for a line edited since.
+    pub saved: [Option<SavedLine>; 4],
+}
+/// A sign line's saved component and the text it showed when it was read.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SavedLine {
+    pub text: String,
+    pub component: Tag,
 }
 /// `SignBlockEntity` / `HangingSignBlockEntity` data.
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
@@ -120,6 +120,16 @@ impl<W: BlockCollisionWorld> BlockCollisionWorld for EntityCollisions<'_, W> {
    ) -> std::result::Result<bool, Self::Error> {
        self.blocks.may_reach_out(chunk, section_y)
    }
+    fn section_is_empty(
+        &mut self,
+        chunk: Self::Chunk,
+        section_y: i32,
+    ) -> std::result::Result<bool, Self::Error> {
+        self.blocks.section_is_empty(chunk, section_y)
+    }
+    fn missing_chunks_stay_missing(&self) -> bool {
+        self.blocks.missing_chunks_stay_missing()
+    }
    fn context_shape(
        &mut self,
        block: CollisionBlock,
@@ -424,6 +434,26 @@ impl<'w> BlockCollisionWorld for SceneCollisions<'w, '_> {
    fn may_reach_out(&mut self, chunk: Self::Chunk, section_y: i32) -> io::Result<bool> {
        Ok(self.section_reaches_out(chunk, section_y))
    }
+    /// From the section's palette: every block it can hold has an empty shape (air, plants).
+    /// A palette of the whole registry, or a section outside the column, is read cell by cell.
+    fn section_is_empty(&mut self, chunk: Self::Chunk, section_y: i32) -> io::Result<bool> {
+        let blocks = usize::try_from(section_y - (chunk.min_y() >> 4))
+            .ok()
+            .and_then(|s| chunk.sections.get(s))
+            .map(|section| &section.blocks);
+        Ok(blocks.is_some_and(|blocks| {
+            !blocks.is_global()
+                && !blocks.maybe_has(|v| {
+                    self.binding
+                        .collision_block(BlockStateId(v))
+                        .map_or(true, |block| !block.empty_shape)
+                })
+        }))
+    }
+    /// The resident columns do not change while a scan runs, and looking one up changes nothing.
+    fn missing_chunks_stay_missing(&self) -> bool {
+        true
+    }
    fn is_suffocating(
        &mut self,
        _: Self::Chunk,
@@ -555,6 +585,9 @@ impl BlockCollisionWorld for EmptyCollisions {
    fn collision_chunk(&mut self, _: ChunkPos) -> io::Result<Option<ChunkPos>> {
        Ok(None)
    }
+    fn missing_chunks_stay_missing(&self) -> bool {
+        true
+    }
    fn collision_block(&mut self, _: ChunkPos, _: BlockPos) -> io::Result<CollisionBlock> {
        Err(io::Error::other("no chunk is resident"))
    }
@@ -215,6 +215,13 @@ impl Campfire {
        }
        changed
    }
+    pub fn idle(&self, lit: bool) -> bool {
+        if lit {
+            self.items.iter().all(Option::is_none)
+        } else {
+            self.progress.iter().all(|&p| p <= 0)
+        }
+    }
 }
 impl Skull {
    pub fn new(
@@ -729,6 +736,56 @@ mod tests {
        assert!(menu_reaches("vanilla", "minecraft:generic_9x3"));
    }

+    #[test]
+    fn a_campfire_is_idle_only_while_its_tick_changes_nothing() {
+        let mut c = Campfire::default();
+        assert!(c.idle(true) && c.idle(false));
+        assert!(c.place_food(&mut ItemStack::new("minecraft:beef", 1), 600));
+        assert!(!c.idle(true));
+        assert!(c.idle(false));
+        c.cook_tick();
+        assert!(!c.idle(false));
+        c.cooldown_tick();
+        assert!(c.idle(false));
+    }
+
+    /// The campfire sleeps while `idle`, so the tick its block runs (`cook_tick` lit,
+    /// `cooldown_tick` unlit) must change nothing then, and must change an awake one.
+    #[test]
+    fn an_idle_campfire_tick_changes_nothing() {
+        let tick = |c: &mut Campfire, lit: bool| {
+            if lit {
+                !c.cook_tick().is_empty()
+            } else {
+                c.cooldown_tick()
+            }
+        };
+        let empty = Campfire::default();
+        let mut food = Campfire::default();
+        assert!(food.place_food(&mut ItemStack::new("minecraft:beef", 1), 600));
+        let mut warm = food.clone();
+        warm.cook_tick();
+        let mut cooled = warm.clone();
+        while cooled.cooldown_tick() {}
+        for (before, lit) in [
+            (&empty, true),
+            (&empty, false),
+            (&food, false),
+            (&cooled, false),
+        ] {
+            assert!(before.idle(lit), "{before:?} lit {lit}");
+            let mut after = before.clone();
+            assert!(!tick(&mut after, lit));
+            assert_eq!(&after, before, "lit {lit}");
+        }
+        for (before, lit) in [(&food, true), (&warm, false)] {
+            assert!(!before.idle(lit), "{before:?} lit {lit}");
+            let mut after = before.clone();
+            tick(&mut after, lit);
+            assert_ne!(&after, before, "lit {lit}");
+        }
+    }
+
    #[test]
    fn campfire_slots_take_food_cook_it_and_cool_down() {
        let mut c = Campfire::default();
@@ -608,7 +608,7 @@ pub struct DataStore {
    /// `item_modifier` files, for `/item modify`.
    pub item_modifiers: BTreeMap<String, serde_json::Value>,
    /// The content tables' raw files from the packs after the built-in one:
-    /// `recipe/`, `recipe_filter/`, `loot_table/`, `advancement/`, `dialog/`, `data_maps/` and `tags/…/` files, by
+    /// `recipe/`, `recipe_filter/`, `loot_table/`, `advancement/`, `dialog/`, `damage_type/`, `data_maps/` and `tags/…/` files, by
    /// `<kind-dir>/<ns>:<path>`, each id's files in pack order. The tables
    /// merge them over what they read from the resource root.
    pub files: BTreeMap<String, Vec<Vec<u8>>>,
@@ -617,7 +617,7 @@ pub struct DataStore {
 }
 /// `<kind-dir>/<ns>:<path>` for a pack file the content tables read:
 /// `recipe/`, `recipe_filter/`, `loot_table/`, `advancement/`, `trade_set/`,
-/// `villager_trade/`, `dialog/`, `data_maps/` or `tags/<sub>/`, where the id keeps the sub
+/// `villager_trade/`, `dialog/`, `damage_type/`, `data_maps/` or `tags/<sub>/`, where the id keeps the sub
 /// path so a nested tag kind stays addressable.
 fn content_id(file: &str) -> Option<String> {
    let rest = file.strip_prefix("data/")?;
@@ -625,7 +625,7 @@ fn content_id(file: &str) -> Option<String> {
    let (kind, rest) = rest.split_once('/')?;
    let kind = match kind {
        "recipe" | "recipe_filter" | "loot_table" | "advancement" | "trade_set"
-        | "villager_trade" | "dialog" | "data_maps" => kind,
+        | "villager_trade" | "dialog" | "damage_type" | "data_maps" => 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).
@@ -656,6 +656,7 @@ impl DataStore {
            let builtin = pack.id == "vanilla";
            for f in pack.list_kinds(&[
                "advancement",
+                "damage_type",
                "data_maps",
                "dialog",
                "function",
@@ -895,6 +896,13 @@ pub fn worldgen_overrides(
    let mut warnings = Vec::new();
    for pack in packs {
        for file in pack.list_kinds(&overrides::PACK_KINDS) {
+            if let Some(id) = overrides::template_id(&file) {
+                match pack.read(&file) {
+                    Some(nbt) => out.set_template(&id, nbt),
+                    None => warnings.push(format!("{}: {file}: unreadable", pack.id)),
+                }
+                continue;
+            }
            let read = || String::from_utf8(pack.read(&file)?).ok();
            match out.add_file(&pack.id, &file, read) {
                PackFile::Read | PackFile::Other => {}
@@ -955,6 +963,7 @@ mod tests {
        for pack in ["a", "b", "off"] {
            write(pack, "pack.mcmeta", "{}");
            write(pack, "data/minecraft/worldgen/noise/cave.json", pack);
+            write(pack, "data/p/structure/room/a.nbt", pack);
            write(
                pack,
                "data/minecraft/tags/worldgen/biome/is_hill.json",
@@ -991,6 +1000,8 @@ mod tests {
            o.entries("noises").collect::<Vec<_>>(),
            [("minecraft:cave", "a")]
        );
+        assert_eq!(o.templates().len(), 1);
+        assert_eq!(&*o.templates()["p:room/a"], b"a");
        assert_eq!(
            o.entries("biomes").collect::<Vec<_>>(),
            [("minecraft:plains", "{}")]
@@ -98,14 +98,42 @@ pub struct Source {
 /// The [`MAX`] sources nearest `camera` within reach, as the shaders read them: camera-relative
 /// position and level. Overwrites `out`.
 pub fn select(sources: &[Source], camera: DVec3, out: &mut Vec<[f32; 4]>) {
+    select_iter(sources.iter().copied(), camera, out);
+}
+
+/// Streaming selection with the same stable distance order as [`select`]. Only the best
+/// [`MAX`] sources are kept, and each source's distance is evaluated once.
+pub fn select_iter(
+    sources: impl IntoIterator<Item = Source>,
+    camera: DVec3,
+    out: &mut Vec<[f32; 4]>,
+) {
    out.clear();
-    let key = |s: &Source| s.at.distance_squared(camera);
-    let mut near: Vec<&Source> = sources
-        .iter()
-        .filter(|s| s.level > 0 && key(s) <= REACH * REACH)
-        .collect();
-    near.sort_by(|a, b| key(a).total_cmp(&key(b)));
-    out.extend(near.into_iter().take(MAX).map(|s| {
+    let mut near = [(
+        0.0_f64,
+        Source {
+            at: DVec3::ZERO,
+            level: 0,
+        },
+    ); MAX];
+    let mut len = 0;
+    for source in sources {
+        let distance = source.at.distance_squared(camera);
+        // The original <= test also rejects NaN and infinite distances.
+        if source.level == 0 || !(0.0..=REACH * REACH).contains(&distance) {
+            continue;
+        }
+        let at = near[..len].partition_point(|(d, _)| d.total_cmp(&distance).is_le());
+        if at == MAX {
+            continue;
+        }
+        // Insert after equal distances: the first MAX sources in input order win ties.
+        let end = len.min(MAX - 1);
+        near.copy_within(at..end, at + 1);
+        near[at] = (distance, source);
+        len = (len + 1).min(MAX);
+    }
+    out.extend(near[..len].iter().map(|(_, s)| {
        let p = (s.at - camera).as_vec3();
        [p.x, p.y, p.z, f32::from(s.level.min(15))]
    }));
@@ -179,6 +207,104 @@ mod tests {
        assert!(out.is_empty());
    }

+    #[test]
+    fn streaming_selection_matches_stable_full_sort() {
+        let camera = DVec3::new(30_000_000.0, -64.0, -30_000_000.0);
+        let mut seed = 0x8469_d28b_314a_723fu64;
+        let mut sources = Vec::new();
+        for i in 0..2048 {
+            let offset = std::array::from_fn::<_, 3, _>(|_| {
+                seed ^= seed << 13;
+                seed ^= seed >> 7;
+                seed ^= seed << 17;
+                (seed % 241) as f64 - 120.0
+            });
+            sources.push(Source {
+                at: camera + DVec3::from(offset),
+                level: (i % 22) as u8,
+            });
+        }
+        sources.extend([
+            Source {
+                at: camera + DVec3::X * 96.0,
+                level: 14,
+            },
+            Source {
+                at: camera - DVec3::X * 96.0,
+                level: 15,
+            },
+            Source {
+                at: camera + DVec3::X * 96.0001,
+                level: 15,
+            },
+            Source {
+                at: DVec3::splat(f64::NAN),
+                level: 15,
+            },
+            Source {
+                at: DVec3::splat(f64::INFINITY),
+                level: 15,
+            },
+        ]);
+        let reference = |input: &[Source], camera: DVec3| {
+            let mut selected: Vec<_> = input
+                .iter()
+                .filter(|s| s.level > 0 && s.at.distance_squared(camera) <= 96.0 * 96.0)
+                .collect();
+            selected.sort_by(|a, b| {
+                a.at.distance_squared(camera)
+                    .total_cmp(&b.at.distance_squared(camera))
+            });
+            selected
+                .into_iter()
+                .take(16)
+                .map(|s| {
+                    let p = (s.at - camera).as_vec3();
+                    [p.x, p.y, p.z, f32::from(s.level.min(15))]
+                })
+                .collect::<Vec<_>>()
+        };
+        let mut out = vec![[999.0; 4]; 20];
+        for input in [sources.clone(), sources.into_iter().rev().collect()] {
+            for n in [0, 1, 15, 16, 17, 40, input.len()] {
+                select_iter(input[..n].iter().copied(), camera, &mut out);
+                assert_eq!(out, reference(&input[..n], camera));
+            }
+            select_iter(input.iter().copied(), DVec3::splat(f64::NAN), &mut out);
+            assert!(out.is_empty());
+        }
+    }
+
+    #[test]
+    fn equal_distances_keep_first_sources_and_reach_is_inclusive() {
+        // Every source ties: neither a different position nor a different light level
+        // may win the sixteenth slot just because it was inserted later.
+        let sources: Vec<_> = (0..40)
+            .map(|i| Source {
+                at: if i % 2 == 0 {
+                    DVec3::X * 96.0
+                } else {
+                    -DVec3::X * 96.0
+                },
+                level: (i % 15 + 1) as u8,
+            })
+            .collect();
+        let mut out = Vec::new();
+        select_iter(sources, DVec3::ZERO, &mut out);
+        assert_eq!(out.len(), 16);
+        for (i, light) in out.iter().enumerate() {
+            assert_eq!(
+                *light,
+                [
+                    if i % 2 == 0 { 96.0 } else { -96.0 },
+                    0.0,
+                    0.0,
+                    (i % 15 + 1) as f32
+                ]
+            );
+        }
+    }
+
    #[test]
    fn light_falls_off_a_level_per_block() {
        let torch = [[0.0, 0.0, 0.0, 14.0]];
@@ -87,7 +87,11 @@ fn entity_light(normal: vec3<f32>, nether: bool) -> f32 {
 // primed TNT flash (5) and at column overlay - 16 for 16..=31 (a creeper's
 // swelling). Alpha 1 changes nothing.
 fn overlay_texel(overlay: u32) -> vec4<f32> {
-    if overlay == 1u || overlay == 8u { return HURT_OVERLAY; }
+    if overlay == 1u || overlay == 8u {
+        // PvP & HUD's hit colour (pvp.rs `Hit::texel`) rides in colored_count.y; 0 is vanilla's.
+        let hit = globals.colored_count.y;
+        return select(HURT_OVERLAY, unpack4x8unorm(hit), hit != 0u);
+    }
    if overlay == 5u { return vec4(1.0, 1.0, 1.0, WHITE_OVERLAY_ALPHA[15]); }
    if overlay >= 16u && overlay < 32u { return vec4(1.0, 1.0, 1.0, WHITE_OVERLAY_ALPHA[overlay - 16u]); }
    return vec4(1.0);
@@ -246,11 +250,18 @@ fn armor_glint_uv(model: vec2<f32>) -> vec2<f32> {
    return vec2(scaled.x * c - scaled.y * s - offset0,
                scaled.x * s + scaled.y * c + offset1);
 }
+// PvP & HUD's glint colour (pvp.rs `Tweaks::glint_texel`, 0 for vanilla's): the sample's
+// brightest channel over the chosen colour, so the shimmer keeps its pattern and strength.
+fn tinted_glint(glint: vec4<f32>, packed: u32) -> vec4<f32> {
+    if packed == 0u { return glint; }
+    let tint = unpack4x8unorm(packed).rgb;
+    return vec4(max(glint.r, max(glint.g, glint.b)) * tint, glint.a);
+}
 // RenderPipelines.GLINT: the source colour is scaled by itself, so `GlintAlpha`
 // is squared along with the sample.
 fn glint_over(color: vec4<f32>, glint: vec4<f32>) -> vec4<f32> {
    let alpha = globals.fog_ends.w;
-    let g = alpha * glint;
+    let g = alpha * tinted_glint(glint, globals.colored_count.z);
    return vec4(color.rgb + g.rgb * g.rgb, max(color.a, alpha));
 }
 // CRUMBLING_UV_BEGIN
@@ -3,7 +3,7 @@
 //! celestial angles and star brightness for the overworld day cycle.
 use crate::Result;
 use serde_json::Value;
-use std::{collections::HashMap, fs, path::Path};
+use std::{collections::HashMap, path::Path};

 #[derive(Clone, Copy, Debug)]
 enum Easing {
@@ -151,13 +151,13 @@ impl Environment {
    /// A dimension's base attributes, optionally driven by the day timeline.
    pub fn load_dimension(root: &Path, dimension: &str, day_cycle: bool) -> Result<Self> {
        let timeline: Value = if day_cycle {
-            serde_json::from_slice(&fs::read(root.join("data/minecraft/timeline/day.json"))?)?
+            horizon_world::json_file::read(&root.join("data/minecraft/timeline/day.json"))?
        } else {
            serde_json::json!({"period_ticks": 24000, "tracks": {}})
        };
-        let dimension: Value = serde_json::from_slice(&fs::read(
-            root.join(format!("data/minecraft/dimension_type/{dimension}.json")),
-        )?)?;
+        let dimension: Value = horizon_world::json_file::read(
+            &root.join(format!("data/minecraft/dimension_type/{dimension}.json")),
+        )?;
        let mut tracks = HashMap::new();
        for (name, track) in timeline["tracks"].as_object().ok_or("invalid timeline")? {
            let easing = match &track["ease"] {
@@ -10,6 +10,9 @@ pub const FILE: &str = "horizon-extras.txt";
 pub const SORT_KEY: &str = "horizon.sort";
 /// The 3D skin layers line, here and in the `options.txt` that held it first.
 const SKIN_LAYERS_KEY: &str = "threeDSkinLayers";
+/// The emote wheel's key, here and in the `key_key.emote` line #10092 wrote to `options.txt`.
+const EMOTE_KEY: &str = "emoteKey";
+const OLD_EMOTE_LINE: &str = "key_key.emote";

 /// The minimap's sizes in GUI pixels, and its zooms in blocks per pixel.
 pub const MINIMAP_SIZES: [(u8, &str); 3] = [(64, "Small"), (96, "Medium"), (128, "Large")];
@@ -46,7 +49,7 @@ impl Corner {
            Corner::BottomRight => "Bottom right",
        }
    }
-    fn parse(s: &str, default: Corner) -> Corner {
+    pub fn parse(s: &str, default: Corner) -> Corner {
        Self::ALL
            .into_iter()
            .find(|c| c.name() == s)
@@ -66,6 +69,8 @@ pub struct Extras {
    /// Modrinth. Off by default: it is Horizon's own and the screen is
    /// otherwise vanilla's (tools/test_pack_screen_parity.py).
    pub pack_browser: bool,
+    /// Make /pregen available in single-player and hosted LAN worlds.
+    pub pregen: bool,
    pub fullbright: bool,
    /// Held, dropped and burning light sources light their surroundings (`dynamic_light`).
    pub dynamic_lights: bool,
@@ -124,6 +129,10 @@ pub struct Extras {
    pub sort: bool,
    /// A vanilla key name: sorts the part under the cursor.
    pub sort_key: String,
+    /// The emote wheel's key (`key.emote`), as the game last saved it. The live binding is
+    /// `Settings::keys`, bound in Controls with the vanilla ones; it is only kept in this file
+    /// so that `options.txt` stays vanilla's (`Settings::load` hands it over, `save` takes it back).
+    pub emote_key: String,
    /// A new chat line slides in from the left while it fades in (`Chat::layout`).
    pub chat_animation: bool,
    /// The indicator bar at the left of a chat line (on by default, as vanilla).
@@ -162,13 +171,21 @@ pub struct Extras {
    /// Cosmetics (`horizon_cosmetics`, off unless enabled), the lines `horizon_cosmetics::prefs`
    /// shares with the launcher's Wardrobe: Show my cosmetics (the account's, sent to the service;
    /// on by default), how much of other players' to show (no line until chosen:
-    /// `effective_others`), and their auras and trails (off by default).
+    /// `effective_others`), and whether their trails and auras are hidden (off by default).
    pub cosmetics_mine: bool,
    pub cosmetics_others: Option<horizon_cosmetics::prefs::Others>,
-    pub cosmetics_auras: bool,
+    pub cosmetics_hide_fx: bool,
+    /// My cosmetics in single player too (`cosmeticsSolo`, off by default): the window's own server
+    /// names the player by their offline profile, which the service doesn't know, so their own
+    /// cosmetics and name tag style show only with this on.
+    pub cosmetics_solo: bool,
    /// Whether the signed-in account owns a cosmetic, as the service said (never saved; the game
    /// sets it): with no choice made, others' cosmetics show only then.
    pub cosmetics_owner: bool,
+    /// Horizon's mark before the names of other Horizon players (name tags, player list), and
+    /// whether the service may say this player plays Horizon: both on by default.
+    pub horizon_marks: bool,
+    pub horizon_listed: bool,
    /// 3D skin layers (`threeDSkinLayers`, Options → Skin Customization): each
    /// painted texel of a player's outer layer drawn as a slab
    /// (`horizon_client::mobs::skin_layers`).
@@ -180,6 +197,7 @@ impl Default for Extras {
    fn default() -> Self {
        Self {
            pack_browser: false,
+            pregen: false,
            fullbright: false,
            dynamic_lights: false,
            zoom: false,
@@ -209,6 +227,7 @@ impl Default for Extras {
            mouse_tweaks_wheel: true,
            sort: false,
            sort_key: "key.keyboard.unknown".into(),
+            emote_key: crate::keybinds::KeyBinds::default_of("key.emote").into(),
            chat_animation: false,
            chat_indicator: true,
            no_ai: false,
@@ -219,13 +238,16 @@ impl Default for Extras {
            splitscreen_two: 0,
            splitscreen_three: 0,
            splitscreen_names: true,
-            wheel_cycles_settings: true,
+            wheel_cycles_settings: false,
            music_off: Vec::new(),
            music_page: false,
            cosmetics_mine: true,
            cosmetics_others: None,
-            cosmetics_auras: false,
+            cosmetics_hide_fx: false,
+            cosmetics_solo: false,
            cosmetics_owner: false,
+            horizon_marks: true,
+            horizon_listed: true,
            three_d_skin_layers: false,
            pvp: Default::default(),
        }
@@ -259,6 +281,7 @@ impl Extras {
            };
            match key.trim() {
                "packBrowser" => e.pack_browser = flag(e.pack_browser),
+                "pregen" => e.pregen = flag(e.pregen),
                "fullbright" => e.fullbright = flag(e.fullbright),
                "dynamicLights" => e.dynamic_lights = flag(e.dynamic_lights),
                "zoom" => e.zoom = flag(e.zoom),
@@ -309,6 +332,7 @@ impl Extras {
                "mouseTweaksWheel" => e.mouse_tweaks_wheel = flag(e.mouse_tweaks_wheel),
                "sort" => e.sort = flag(e.sort),
                "sortKey" if value.starts_with("key.") => e.sort_key = value.to_owned(),
+                EMOTE_KEY if value.starts_with("key.") => e.emote_key = value.to_owned(),
                "chatAnimation" => e.chat_animation = flag(e.chat_animation),
                "chatIndicator" => e.chat_indicator = flag(e.chat_indicator),
                horizon_core::no_ai::KEY => e.no_ai = flag(e.no_ai),
@@ -319,7 +343,11 @@ impl Extras {
                "splitscreenTwo" => e.splitscreen_two = value.parse().unwrap_or(0).min(2),
                "splitscreenThree" => e.splitscreen_three = value.parse().unwrap_or(0).min(2),
                "splitscreenNames" => e.splitscreen_names = flag(e.splitscreen_names),
-                "wheelCyclesSettings" => e.wheel_cycles_settings = flag(e.wheel_cycles_settings),
+                // A new name: `wheelCyclesSettings` was written as true by every
+                // install while it was the default, so it says nothing of a choice.
+                "wheelCyclesListSettings" => {
+                    e.wheel_cycles_settings = flag(e.wheel_cycles_settings)
+                }
                "musicOff" => {
                    e.music_off = value
                        .split(',')
@@ -334,7 +362,10 @@ impl Extras {
                    e.cosmetics_others =
                        horizon_cosmetics::prefs::Others::parse(value).or(e.cosmetics_others)
                }
-                "cosmeticsAuras" => e.cosmetics_auras = flag(e.cosmetics_auras),
+                "cosmeticsHideFx" => e.cosmetics_hide_fx = flag(e.cosmetics_hide_fx),
+                "cosmeticsSolo" => e.cosmetics_solo = flag(e.cosmetics_solo),
+                horizon_cosmetics::prefs::MARKS => e.horizon_marks = flag(e.horizon_marks),
+                horizon_cosmetics::prefs::LISTED => e.horizon_listed = flag(e.horizon_listed),
                SKIN_LAYERS_KEY => e.three_d_skin_layers = flag(e.three_d_skin_layers),
                key => {
                    e.pvp.parse_line(key, value);
@@ -345,8 +376,9 @@ impl Extras {
    }
    pub fn serialize(&self) -> String {
        let mut text = format!(
-            "packBrowser:{}\nfullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nlodZoomDetail:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nmovedToMods:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nuiSoundReserve:{}\nownNameTag:{}\nhideBlockParticles:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\nchatAnimation:{}\nchatIndicator:{}\n{}:{}\nagentControl:{}\nreproKeys:{}\ndiscordPresence:{}\nsplitscreen:{}\nsplitscreenTwo:{}\nsplitscreenThree:{}\nsplitscreenNames:{}\nwheelCyclesSettings:{}\nmusicOff:{}\nmusicPage:{}\ncosmeticsMine:{}\n{}cosmeticsAuras:{}\n{}:{}\n",
+            "packBrowser:{}\npregen:{}\nfullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nlodZoomDetail:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nmovedToMods:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nuiSoundReserve:{}\nownNameTag:{}\nhideBlockParticles:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\nchatAnimation:{}\nchatIndicator:{}\n{}:{}\nagentControl:{}\nreproKeys:{}\ndiscordPresence:{}\nsplitscreen:{}\nsplitscreenTwo:{}\nsplitscreenThree:{}\nsplitscreenNames:{}\nwheelCyclesListSettings:{}\nmusicOff:{}\nmusicPage:{}\ncosmeticsMine:{}\n{}cosmeticsHideFx:{}\ncosmeticsSolo:{}\n{}:{}\n{}:{}\n{}:{}\n",
            bool_text(self.pack_browser),
+            bool_text(self.pregen),
            bool_text(self.fullbright),
            bool_text(self.dynamic_lights),
            bool_text(self.zoom),
@@ -398,36 +430,53 @@ impl Extras {
            // Written once the player chose.
            self.cosmetics_others
                .map_or(String::new(), |o| format!("cosmeticsOthers:{}\n", o.name())),
-            bool_text(self.cosmetics_auras),
+            bool_text(self.cosmetics_hide_fx),
+            bool_text(self.cosmetics_solo),
+            horizon_cosmetics::prefs::MARKS,
+            bool_text(self.horizon_marks),
+            horizon_cosmetics::prefs::LISTED,
+            bool_text(self.horizon_listed),
            SKIN_LAYERS_KEY,
            bool_text(self.three_d_skin_layers),
        );
+        text.push_str(&format!("{EMOTE_KEY}:{}\n", self.emote_key));
        self.pvp.serialize(&mut text);
        text
    }
    /// Adopts the settings `options.txt` held before they moved here, while
-    /// this file (`own`) has no line of its own: 3D skin layers was an
-    /// `options.txt` line. Vanilla's `Options.save` drops lines it doesn't
+    /// this file (`own`) has no line of its own: 3D skin layers and the emote key were
+    /// `options.txt` lines. Vanilla's `Options.save` drops lines it doesn't
    /// know, so it is read there once, the first start after the update.
    pub fn read_old_options(&mut self, own: &str, options_txt: &str) {
-        fn line(text: &str) -> Option<&str> {
+        fn line<'a>(text: &'a str, name: &str) -> Option<&'a str> {
            text.lines().find_map(|l| {
                l.split_once(':')
-                    .filter(|(key, _)| *key == SKIN_LAYERS_KEY)
+                    .filter(|(key, _)| *key == name)
                    .map(|(_, value)| value)
            })
        }
-        if line(own).is_none()
-            && let Some(value) = line(options_txt)
+        if line(own, SKIN_LAYERS_KEY).is_none()
+            && let Some(value) = line(options_txt, SKIN_LAYERS_KEY)
        {
            self.three_d_skin_layers = value == "true";
        }
+        // The emote key was a `key_key.emote` line of options.txt (#10092): a rebound key is kept.
+        if line(own, EMOTE_KEY).is_none()
+            && let Some(value) = line(options_txt, OLD_EMOTE_LINE).map(str::trim)
+            && value.starts_with("key.")
+            && (value == "key.keyboard.unknown"
+                || crate::keybinds::key_code(value).is_some()
+                || crate::keybinds::mouse_button(value).is_some())
+        {
+            self.emote_key = value.to_owned();
+        }
    }
    /// Binds the extra key `name` (`SORT_KEY`); false for
    /// another name (a vanilla mapping).
    pub fn set_key(&mut self, name: &str, value: String) -> bool {
        match name {
            SORT_KEY => self.sort_key = value,
+            crate::pvp::HUD_EDITOR_KEY => self.pvp.editor_key = value,
            _ => return false,
        }
        true
@@ -570,24 +619,25 @@ pub enum Item {
    WheelCyclesSettings,
    /// The Select Resource Packs screen's Add button (Modrinth).
    PackBrowser,
+    Pregen,
    /// Shown only while cosmetics are enabled (`horizon_cosmetics::enabled`).
    CosmeticsMine,
    CosmeticsOthers,
-    CosmeticsAuras,
+    CosmeticsHideFx,
+    CosmeticsSolo,
+    HorizonMarks,
+    HorizonMe,
    /// On the PvP & HUD page (`pvp::rows`).
    Pvp(crate::pvp::Opt),
 }
 /// The Extras page: headers (language keys) and items.
 pub fn rows() -> Vec<Result<Item, &'static str>> {
    use Item::*;
+    // Fullbright, Dynamic lights and Hide block-break particles change the picture: they
+    // are on the graphics screen's Quality page (`graphics_ui::rows`), not here.
    let mut rows = vec![
-        Err("horizon.extras.header.lighting"),
-        Ok(Fullbright),
-        Ok(DynamicLights),
        Err("horizon.extras.header.third_person"),
        Ok(OwnNameTag),
-        Err("horizon.extras.header.particles"),
-        Ok(HideBlockParticles),
        Err("horizon.extras.header.inventory"),
        Ok(MouseTweaks),
        Ok(MouseTweaksWheel),
@@ -596,6 +646,8 @@ pub fn rows() -> Vec<Result<Item, &'static str>> {
        Err("horizon.extras.header.chat"),
        Ok(ChatAnimation),
        Ok(ChatIndicator),
+        Err("horizon.extras.header.world"),
+        Ok(Pregen),
        Err("horizon.extras.header.multiplayer"),
        Ok(AutoReconnect),
        Err("horizon.extras.header.sound"),
@@ -609,8 +661,11 @@ pub fn rows() -> Vec<Result<Item, &'static str>> {
        rows.extend([
            Err("horizon.extras.header.cosmetics"),
            Ok(CosmeticsMine),
+            Ok(CosmeticsSolo),
            Ok(CosmeticsOthers),
-            Ok(CosmeticsAuras),
+            Ok(CosmeticsHideFx),
+            Ok(HorizonMarks),
+            Ok(HorizonMe),
        ]);
    }
    rows
@@ -639,9 +694,13 @@ impl Item {
            Item::ChatIndicator => "horizon.extras.chat_indicator",
            Item::WheelCyclesSettings => "horizon.extras.wheel_cycles_settings",
            Item::PackBrowser => "horizon.extras.pack_browser",
+            Item::Pregen => "horizon.extras.pregen",
            Item::CosmeticsMine => "horizon.extras.cosmetics_mine",
            Item::CosmeticsOthers => "horizon.extras.cosmetics_others",
-            Item::CosmeticsAuras => "horizon.extras.cosmetics_auras",
+            Item::CosmeticsHideFx => "horizon.extras.cosmetics_hide_fx",
+            Item::CosmeticsSolo => "horizon.extras.cosmetics_solo",
+            Item::HorizonMarks => "horizon.extras.horizon_marks",
+            Item::HorizonMe => "horizon.extras.horizon_me",
            Item::Pvp(o) => o.caption_key(),
        }
    }
@@ -666,11 +725,15 @@ impl Item {
            Item::Splitscreen => "horizon.extras.splitscreen.tooltip",
            Item::ChatAnimation => "horizon.extras.chat_animation.tooltip",
            Item::ChatIndicator => "horizon.extras.chat_indicator.tooltip",
-            Item::WheelCyclesSettings => "horizon.extras.wheel_cycles_settings.tooltip",
+            Item::WheelCyclesSettings => "horizon.extras.wheel_cycles_list_settings.tooltip",
            Item::PackBrowser => "horizon.extras.pack_browser.tooltip",
+            Item::Pregen => "horizon.extras.pregen.tooltip",
            Item::CosmeticsMine => "horizon.extras.cosmetics_mine.tooltip",
            Item::CosmeticsOthers => "horizon.extras.cosmetics_others.tooltip",
-            Item::CosmeticsAuras => "horizon.extras.cosmetics_auras.tooltip",
+            Item::CosmeticsHideFx => "horizon.extras.cosmetics_hide_fx.tooltip",
+            Item::CosmeticsSolo => "horizon.extras.cosmetics_solo.tooltip",
+            Item::HorizonMarks => "horizon.extras.horizon_marks.tooltip",
+            Item::HorizonMe => "horizon.extras.horizon_me.tooltip",
            Item::Pvp(o) => o.description_key(),
        }
    }
@@ -706,9 +769,13 @@ impl Item {
            Item::Splitscreen => "Splitscreen",
            Item::WheelCyclesSettings => "Scroll wheel changes settings",
            Item::PackBrowser => "Resource pack browser",
+            Item::Pregen => "Chunk pregeneration",
            Item::CosmeticsMine => "My cosmetics",
            Item::CosmeticsOthers => "Other players' cosmetics",
-            Item::CosmeticsAuras => "Others' auras and trails",
+            Item::CosmeticsHideFx => "Hide other players' trails and auras",
+            Item::CosmeticsSolo => "In single player",
+            Item::HorizonMarks => "Horizon logos",
+            Item::HorizonMe => "Show me as Horizon",
            Item::Pvp(o) => o.caption(),
        }
    }
@@ -724,7 +791,8 @@ impl Item {
            Fullbright | DynamicLights | OwnNameTag | HideBlockParticles | MouseTweaks | Sort
            | AutoReconnect | NoAi | AgentControl | ReproKeys | DiscordPresence | Splitscreen
            | ChatAnimation | WheelCyclesSettings | MusicPage | PackBrowser | CosmeticsMine
-            | CosmeticsOthers | CosmeticsAuras => {
+            | CosmeticsOthers | CosmeticsHideFx | CosmeticsSolo | HorizonMarks | HorizonMe
+            | Pregen => {
                return None;
            }
        })
@@ -732,6 +800,9 @@ impl Item {
    /// The English description: the fallback of [`Item::description_text`].
    pub fn description(self) -> &'static str {
        match self {
+            Item::Pregen => {
+                "Enables /pregen in your single-player and LAN worlds. With cheats enabled, use /pregen start to generate an area before exploring it. Does not enable the command on servers you join."
+            }
            Item::Fullbright => "Show blocks and entities at full light, even in dark areas.",
            Item::DynamicLights => {
                "Torches and other light sources held, dropped or on fire light the blocks around them."
@@ -788,7 +859,18 @@ impl Item {
            Item::CosmeticsOthers => {
                "What other Horizon players wear: everything, only their name tag styles, or nothing. Hidden unless you own cosmetics, until you choose. Hidden, the game never asks what they wear."
            }
-            Item::CosmeticsAuras => "Auras and trails other players wear. Off by default.",
+            Item::CosmeticsHideFx => {
+                "Other players' trails and auras stay hidden; their other cosmetics still show. Off by default."
+            }
+            Item::CosmeticsSolo => {
+                "Show your cosmetics and your name tag's badge in your single-player worlds too (your name tag with Own name tag). Off: only on servers."
+            }
+            Item::HorizonMarks => {
+                "Show the Horizon logo next to Horizon players: a small logo before the names of other players who use Horizon, above their heads and in the player list. Only Horizon players see it: servers receive nothing."
+            }
+            Item::HorizonMe => {
+                "Show me as a Horizon player: other Horizon players see the logo by your name. On, the service answers anyone who asks about you that you played Horizon in the last 3 hours; off, it never reports you."
+            }
            Item::Pvp(o) => o.description(),
            Item::WheelCyclesSettings => {
                "The scroll wheel over a button in the settings changes its value, as in vanilla. Off, the wheel only scrolls the list."
@@ -815,7 +897,12 @@ impl Item {
            | Item::Splitscreen
            | Item::WheelCyclesSettings
            | Item::PackBrowser => Some(Cost::None),
-            Item::CosmeticsMine | Item::CosmeticsOthers | Item::CosmeticsAuras => Some(Cost::Low),
+            Item::CosmeticsMine
+            | Item::CosmeticsOthers
+            | Item::CosmeticsHideFx
+            | Item::CosmeticsSolo
+            | Item::HorizonMarks
+            | Item::HorizonMe => Some(Cost::Low),
            _ => None,
        }
    }
@@ -841,7 +928,11 @@ impl Item {
            Item::Splitscreen => e.splitscreen,
            Item::WheelCyclesSettings => e.wheel_cycles_settings,
            Item::PackBrowser => e.pack_browser,
-            Item::CosmeticsAuras => e.cosmetics_auras,
+            Item::Pregen => e.pregen,
+            Item::CosmeticsHideFx => e.cosmetics_hide_fx,
+            Item::CosmeticsSolo => e.cosmetics_solo,
+            Item::HorizonMarks => e.horizon_marks,
+            Item::HorizonMe => e.horizon_listed,
            Item::Pvp(o) => return o.switch(&e.pvp),
            _ => return None,
        })
@@ -896,13 +987,17 @@ impl Item {
            Item::Splitscreen => e.splitscreen = !e.splitscreen,
            Item::WheelCyclesSettings => e.wheel_cycles_settings = !e.wheel_cycles_settings,
            Item::PackBrowser => e.pack_browser = !e.pack_browser,
+            Item::Pregen => e.pregen = !e.pregen,
            Item::CosmeticsMine => e.cosmetics_mine = !e.cosmetics_mine,
            Item::CosmeticsOthers => {
                // From what the button shows; the result is the player's choice from now on.
                let o = e.effective_others();
                e.cosmetics_others = Some(if back { o.next().next() } else { o.next() });
            }
-            Item::CosmeticsAuras => e.cosmetics_auras = !e.cosmetics_auras,
+            Item::CosmeticsHideFx => e.cosmetics_hide_fx = !e.cosmetics_hide_fx,
+            Item::CosmeticsSolo => e.cosmetics_solo = !e.cosmetics_solo,
+            Item::HorizonMarks => e.horizon_marks = !e.horizon_marks,
+            Item::HorizonMe => e.horizon_listed = !e.horizon_listed,
            Item::Pvp(o) => o.cycle(&mut e.pvp, back),
            Item::SortKey => {}
        }
@@ -911,6 +1006,7 @@ impl Item {
    pub fn key_name(self) -> Option<&'static str> {
        match self {
            Item::SortKey => Some(SORT_KEY),
+            Item::Pvp(crate::pvp::Opt::HudEditorKey) => Some(crate::pvp::HUD_EDITOR_KEY),
            _ => None,
        }
    }
@@ -928,7 +1024,7 @@ mod tests {
            ..Extras::default()
        };
        assert_eq!(
-            (e.effective_others(), e.cosmetics_auras, e.cosmetics_mine),
+            (e.effective_others(), e.cosmetics_hide_fx, e.cosmetics_mine),
            (Others::Shown, false, true)
        );
        Item::CosmeticsOthers.cycle(&mut e, false);
@@ -987,15 +1083,25 @@ mod tests {
        assert_eq!(hidden.effective_others(), Others::Hidden);
    }

+    #[test]
+    fn a_saved_wheel_setting_from_before_the_default_changed_is_dropped() {
+        assert!(!Extras::parse("wheelCyclesSettings:true\n").wheel_cycles_settings);
+        let on = Extras {
+            wheel_cycles_settings: true,
+            ..Extras::default()
+        };
+        assert!(Extras::parse(&on.serialize()).wheel_cycles_settings);
+    }
+
    #[test]
    fn everything_is_off_by_default_and_round_trips() {
        let d = Extras::default();
        assert!(!d.fullbright && !d.dynamic_lights);
        assert!(!d.zoom && !d.fps && !d.keystrokes && !d.minimap && !d.auto_reconnect);
        assert!(!d.mouse_tweaks && !d.sort && !d.own_name_tag && !d.ui_sound_reserve);
-        assert!(!d.hide_block_particles);
+        assert!(!d.hide_block_particles && !d.pregen);
        assert!(!d.music_page && d.music_off.is_empty());
-        assert!(d.discord_presence && d.wheel_cycles_settings);
+        assert!(d.discord_presence && !d.wheel_cycles_settings);
        assert_eq!(Extras::parse(""), d);
        assert_eq!(Extras::parse(&d.serialize()), d);
        let mut e = d.clone();
@@ -1018,6 +1124,8 @@ mod tests {
        e.minimap_rotate = true;
        e.minimap_corner = Corner::BottomLeft;
        e.auto_reconnect = true;
+        Item::Pregen.cycle(&mut e, false);
+        assert_eq!(Item::Pregen.switch(&e), Some(true));
        Item::OwnNameTag.cycle(&mut e, false);
        assert_eq!(Item::OwnNameTag.switch(&e), Some(true));
        assert_eq!(Item::HideBlockParticles.switch(&e), Some(false));
@@ -1037,7 +1145,7 @@ mod tests {
        Item::Splitscreen.cycle(&mut e, false);
        assert_eq!(Item::Splitscreen.switch(&e), Some(true));
        Item::WheelCyclesSettings.cycle(&mut e, false);
-        assert_eq!(Item::WheelCyclesSettings.switch(&e), Some(false));
+        assert_eq!(Item::WheelCyclesSettings.switch(&e), Some(true));
        e.music_off = vec![
            "minecraft:music/game/calm1".into(),
            "minecraft:music.menu".into(),
@@ -212,8 +212,11 @@ pub struct FogInputs<'a> {
    pub boss_world_fog: bool,
    /// The camera entity is a spectator (`LavaFogEnvironment`).
    pub spectator: bool,
-    /// The camera entity has Fire Resistance (`LavaFogEnvironment`).
+    /// The camera entity has Fire Resistance (`LavaFogEnvironment`), or PvP & HUD's clear lava
+    /// asks for its fog.
    pub fire_resistance: bool,
+    /// PvP & HUD's clear water: the water vision `FogState` reaches after 600 ticks under water.
+    pub full_water_vision: bool,
    /// `GameRenderer.nightVisionScale` while Night Vision is on without
    /// Darkness, else 0 (`FogRenderer.computeFogColor`'s brightenFactor).
    pub night_vision: f32,
@@ -224,7 +227,11 @@ pub fn setup_fog(tables: &FogTables, state: &FogState, input: &FogInputs) -> Fog
    let rd = input.render_distance_chunks as f32 * 16.0;
    let sky = input.sky;
    let eye_in_water = input.fog_type == FogType::Water;
-    let water_vision = state.water_vision(eye_in_water);
+    let water_vision = if input.full_water_vision && eye_in_water {
+        1.0
+    } else {
+        state.water_vision(eye_in_water)
+    };
    // Base colour of the applicable environment.
    let mut color = match input.fog_type {
        FogType::Lava => rgb(0x99_1A00),
@@ -406,6 +413,13 @@ pub fn clear_distance_fog(fog: &mut FogData, input: &FogInputs) {
        (fog.environmental_start, fog.environmental_end) = (1e9, 2e9);
    }
 }
+/// Whether the frame draws no sky, only the clear to the fog colour: `LevelRenderer.addSkyPass`
+/// leaves the sky out in lava and powder snow and while blindness or darkness is on (`Camera`'s
+/// `doesMobEffectBlockSky`), and `GameRenderer.renderLevel` gives `LevelRenderer.render`
+/// `shouldRenderSky` false while a boss bar makes world fog (the Ender Dragon's).
+pub fn sky_pass_skipped(fog_type: FogType, effect_blocks_sky: bool, boss_world_fog: bool) -> bool {
+    matches!(fog_type, FogType::Lava | FogType::PowderSnow) || effect_blocks_sky || boss_world_fog
+}
 /// `AtmosphericFogEnvironment.updateRainFogState`.
 pub fn update_rain_fog(
    state: &mut FogState,
@@ -451,6 +465,7 @@ mod tests {
            boss_world_fog: false,
            spectator: false,
            fire_resistance: false,
+            full_water_vision: false,
            night_vision: 0.0,
        }
    }
@@ -472,6 +487,20 @@ mod tests {
        assert_eq!(fog(surface - 0.01, -90.0), FogType::Atmospheric);
    }
    #[test]
+    fn the_dragon_fights_world_fog_leaves_out_the_sky() {
+        use FogType::*;
+        // GameRenderer.renderLevel: no sky pass under a createWorldFog boss bar, in clear air
+        // as in water.
+        assert!(sky_pass_skipped(Atmospheric, false, true));
+        assert!(sky_pass_skipped(Water, false, true));
+        // LevelRenderer.addSkyPass's own conditions.
+        assert!(sky_pass_skipped(Lava, false, false));
+        assert!(sky_pass_skipped(PowderSnow, false, false));
+        assert!(sky_pass_skipped(Atmospheric, true, false));
+        assert!(!sky_pass_skipped(Atmospheric, false, false));
+        assert!(!sky_pass_skipped(Water, false, false));
+    }
+    #[test]
    fn boss_world_fog_closes_in() {
        // AtmosphericFogEnvironment.setupFog under a createWorldFog boss bar.
        let sky = Sky {
@@ -673,6 +702,31 @@ mod tests {
        assert_eq!(s.water_vision(false), 0.0);
    }
    #[test]
+    fn clear_water_sees_as_far_as_after_thirty_seconds_under_water() {
+        let sky = Sky::default();
+        let tables = FogTables {
+            water_fog_end: vec![1.0],
+        };
+        let mut input = inputs(&sky);
+        input.fog_type = FogType::Water;
+        // Just in: vanilla's water vision is 0, so the fog ends at a quarter of 96 blocks.
+        let mut state = FogState::default();
+        state.tick(true);
+        let first = setup_fog(&tables, &state, &input);
+        assert_eq!(first.environmental_end, 24.0);
+        for _ in 0..600 {
+            state.tick(true);
+        }
+        let settled = setup_fog(&tables, &state, &input);
+        assert_eq!(settled.environmental_end, 96.0);
+        input.full_water_vision = true;
+        let mut fresh = FogState::default();
+        fresh.tick(true);
+        let clear = setup_fog(&tables, &fresh, &input);
+        assert_eq!(clear.environmental_end, settled.environmental_end);
+        assert_eq!(clear.color, settled.color);
+    }
+    #[test]
    fn rain_fog_pulls_fog_in() {
        let sky = Sky {
            fog_end: 1024.0,
@@ -936,6 +936,10 @@ impl Font {
            offset: 0.5,
        })
    }
+    /// Starts the random `random_glyph` draws on over from `seed`.
+    pub fn reseed(&self, seed: i64) {
+        self.cache.borrow_mut().random = horizon_core::random::LegacyRandom::new(seed);
+    }
    /// `FontSet.getRandomGlyph`: what an obfuscated character draws, a random
    /// glyph of the font as wide as `advance` (rounded up), else the missing
    /// glyph.
@@ -517,6 +517,7 @@ impl Scene {
            outline: Vec::new(),
            outline_after_terrain: false,
            outline_high_contrast: false,
+            pvp: Default::default(),
            debug_lines: &[],
            debug_lines_on_top: &[],
            debug_crosshair: &[],
@@ -548,6 +549,7 @@ impl Scene {
            lightning: Default::default(),
            additive: &[],
            see_through: &[],
+            world_primitives: Default::default(),
            shadow_only: &[],
            celestial: &self.celestial,
            stars: f
@@ -55,6 +55,13 @@ const RETEST: u32 = 8;
 /// more than they save. Else one frame in `PROBE` tests every section.
 const MIN_SHARE: f32 = 0.1;
 const PROBE: u32 = 64;
+/// The gate, for frame `stamp`, with `share` the newest result's hidden share:
+/// whether the frame culls, and whether it probes (tests every section). GPU
+/// culling's frames take it too.
+pub(super) fn gate(share: f32, stamp: u32) -> (bool, bool) {
+    let probe = share < MIN_SHARE;
+    (!probe || stamp.is_multiple_of(PROBE), probe)
+}
 /// On Metal, sections in view from which a frame culls. Apple's GPUs store
 /// and reload the whole frame at each of the passes the test adds, a fixed
 /// cost that the sections it hides repay only at high render distances: on
@@ -213,7 +220,7 @@ impl Cull {
    /// write storage.
    pub fn supported(adapter: &wgpu::Adapter, device: &wgpu::Device) -> Option<DepthTest> {
        let depth_test = match adapter.get_info().backend {
-            wgpu::Backend::Vulkan
+            wgpu::Backend::Vulkan | wgpu::Backend::Gl
                if device
                    .features()
                    .contains(wgpu::Features::SHADER_EARLY_DEPTH_TEST) =>
@@ -232,6 +239,11 @@ impl Cull {
            ))
        .then_some(depth_test)
    }
+    /// Its test runs in phase 1's pass, the depth test forced early (Vulkan):
+    /// GPU culling's frames can run it too.
+    pub fn early(&self) -> bool {
+        self.depth_test == DepthTest::Early
+    }
    /// `color` is the world pass's colour format.
    pub fn new(device: &wgpu::Device, color: wgpu::TextureFormat, depth_test: DepthTest) -> Self {
        let entry = |binding, visibility, ty| wgpu::BindGroupLayoutEntry {
@@ -275,7 +287,7 @@ impl Cull {
                    0,
                    fragment,
                    wgpu::BindingType::Texture {
-                        sample_type: wgpu::TextureSampleType::Depth,
+                        sample_type: wgpu::TextureSampleType::Float { filterable: false },
                        view_dimension: wgpu::TextureViewDimension::D2,
                        multisampled: false,
                    },
@@ -422,8 +434,12 @@ impl Cull {
        self.test_slots.clear();
        self.test_indices.clear();
        self.total = 0;
-        self.probe = !self.always && self.hidden.1 < MIN_SHARE;
-        !self.probe || self.stamp.is_multiple_of(PROBE)
+        let (culls, probe) = match self.always {
+            true => (true, false),
+            false => gate(self.hidden.1, self.stamp),
+        };
+        self.probe = probe;
+        culls
    }

    /// Whether phase 1 draws the section in resident `slot` (or the far tile
@@ -718,6 +734,15 @@ fn source(depth_test: DepthTest) -> String {
 mod tests {
    use super::*;

+    /// Culling while the newest result hid enough; else one frame in `PROBE`
+    /// tests every section. GPU culling's frames take the same gate.
+    #[test]
+    fn the_gate_culls_while_enough_is_hidden_and_probes_else() {
+        assert_eq!(gate(MIN_SHARE, 3), (true, false));
+        assert_eq!(gate(MIN_SHARE / 2.0, 3), (false, true));
+        assert_eq!(gate(MIN_SHARE / 2.0, PROBE), (true, true));
+    }
+
    #[test]
    fn shaders_validate() {
        for (depth_test, capabilities) in [
@@ -114,8 +114,10 @@ fn see(t: u32) {
    }
 }

-// Phase 1's depth, where the test runs in the shader (gfx/cull.rs).
-@group(1) @binding(0) var depth: texture_depth_2d;
+// Phase 1's depth, where the test runs in the shader (gfx/cull.rs). A depth
+// view bound as an unfilterable float: naga's GLSL backend cannot `textureLoad`
+// a depth texture, and the texel is the same value.
+@group(1) @binding(0) var depth: texture_2d<f32>;

 // The world pass's reversed depth test, greater or equal passing, made here:
 // where it cannot be forced before a shader that writes storage, a fragment
@@ -123,7 +125,7 @@ fn see(t: u32) {
 // runs only for the fragments that pass it.
@fragment
 fn fs_box(in: Box) {
-    if in.position.z >= textureLoad(depth, vec2<u32>(in.position.xy), 0) {
+    if in.position.z >= textureLoad(depth, vec2<u32>(in.position.xy), 0).r {
        see(in.test);
    }
 }
@@ -14,7 +14,8 @@ use super::Vertex;
 /// material at the end: the render types vanilla gives an `OitPipelineSet`
 /// (translucent, emissive, eyes and breeze wind entity models). Off, the tag is
 /// ignored and they stay in the first one, in their order.
-const MATERIALS: usize = 10;
+/// Two native world-canvas text materials follow it, NORMAL then POLYGON_OFFSET.
+const MATERIALS: usize = 12;
 /// A bit of `Vertex::layer`, above the overlay (low 16 bits) and the HDR tier
 /// (bits 16 to 23): the quad's render type has an `OitPipelineSet`
 /// (`RenderTypes.entityTranslucent`, `entityTranslucentEmissive`, `eyes`,
@@ -51,6 +52,10 @@ pub const TRANSLUCENT_GLINT_ITEM_OVERLAY: u32 = 33;
 /// The overlay of text in `Font.DisplayMode.POLYGON_OFFSET` (text displays):
 /// drawn like an ordinary entity, pulled toward the camera.
 pub const TEXT_POLYGON_OFFSET_OVERLAY: u32 = 35;
+/// A native world canvas, drawn after particles with normal text depth/culling.
+pub const WORLD_TEXT_OVERLAY: u32 = 39;
+/// The front of its eight-offset outlined text, using POLYGON_OFFSET.
+pub const WORLD_TEXT_POLYGON_OFFSET_OVERLAY: u32 = 40;

 /// The material of a quad by its overlay (`MATERIALS` order): the overlay is the layer's low 16
 /// bits, as entity.wgsl reads it; HDR output's tier rides in the high ones.
@@ -59,6 +64,8 @@ fn material(layer: u32, oit: bool) -> usize {
        return 9;
    }
    match layer & 0xffff {
+        WORLD_TEXT_OVERLAY => 10,
+        WORLD_TEXT_POLYGON_OFFSET_OVERLAY => 11,
        TEXT_POLYGON_OFFSET_OVERLAY => 1,
        11 => 2,
        12 => 3,
@@ -118,7 +125,7 @@ impl EntityBatch {
        self.combined.clear();
        self.combined
            .reserve(entity_vertices + additive.len() + hand.len() + see_through.len());
-        for runs in &self.runs {
+        for runs in &self.runs[..10] {
            for &(first, count) in runs {
                self.combined
                    .extend_from_slice(&entities[first * 4..(first + count) * 4]);
@@ -141,6 +148,27 @@ impl EntityBatch {
                }
            }
        }
+        // RenderType.text sorts alpha-blended quads from far to near. Keep
+        // both world-canvas layers after existing materials (including eyes
+        // moved out of additive); front text uses polygon offset.
+        for runs in &self.runs[10..] {
+            let start = self.combined.len();
+            for &(first, count) in runs {
+                self.combined
+                    .extend_from_slice(&entities[first * 4..(first + count) * 4]);
+            }
+            self.combined[start..]
+                .as_chunks_mut::<4>()
+                .0
+                .sort_by(|a, b| {
+                    let distance = |q: &[Vertex; 4]| {
+                        (0..3)
+                            .map(|i| ((q[0].pos[i] + q[2].pos[i]) * 0.5).powi(2))
+                            .sum::<f32>()
+                    };
+                    distance(b).total_cmp(&distance(a))
+                });
+        }
        if self.moved_additive == 0 {
            self.combined.extend_from_slice(additive);
        } else {
@@ -160,6 +188,41 @@ impl EntityBatch {
 mod tests {
    use super::*;
    use std::{hint::black_box, time::Instant};
+    #[test]
+    fn world_canvas_sorts_after_oit_eyes_before_frame_tails() {
+        let quad = |layer, x| {
+            [Vertex {
+                layer,
+                pos: [x, 0.0, 0.0],
+                ..geometry(1, false)[0]
+            }; 4]
+        };
+        let entities: Vec<_> = [
+            (0, 1.0),
+            (35, 2.0),
+            (OIT_ENTITY, 3.0),
+            (WORLD_TEXT_OVERLAY, 4.0),
+            (WORLD_TEXT_OVERLAY, 5.0),
+            (WORLD_TEXT_POLYGON_OFFSET_OVERLAY, 6.0),
+        ]
+        .into_iter()
+        .flat_map(|(layer, x)| quad(layer, x))
+        .collect();
+        let additive: Vec<_> = [(OIT_ENTITY | 2, 7.0), (2, 8.0)]
+            .into_iter()
+            .flat_map(|(layer, x)| quad(layer, x))
+            .collect();
+        let mut batch = EntityBatch::default();
+        assert_eq!(
+            batch.update(&entities, &additive, &quad(0, 9.0), &quad(0, 10.0), true),
+            [1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 1]
+        );
+        let positions: Vec<_> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
+        assert_eq!(
+            positions,
+            [1.0, 2.0, 3.0, 7.0, 5.0, 4.0, 6.0, 8.0, 9.0, 10.0]
+        );
+    }

    // Retain the original implementation as the equivalence/benchmark oracle.
    fn baseline(
@@ -257,12 +320,12 @@ mod tests {
        let mut batch = EntityBatch::default();
        // Off: the tag changes nothing, the quads keep their place.
        let counts = batch.update(&entities, &[], &[], &[], false);
-        assert_eq!(counts, [4, 0, 0, 0, 0, 0, 1, 0, 0, 0]);
+        assert_eq!(counts, [4, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]);
        let xs: Vec<f32> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
        assert_eq!(xs, [0.0, 1.0, 2.0, 4.0, 3.0]);
        // On: the tagged quads come last, in order.
        let counts = batch.update(&entities, &[], &[], &[], true);
-        assert_eq!(counts, [2, 0, 0, 0, 0, 0, 1, 0, 0, 2]);
+        assert_eq!(counts, [2, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0]);
        let xs: Vec<f32> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
        assert_eq!(xs, [0.0, 2.0, 3.0, 1.0, 4.0]);
    }
@@ -52,7 +52,9 @@ struct Params {

@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;
+// A depth view bound as unfilterable float: naga's GLSL backend cannot
+// `textureLoad` a depth texture, and the texel is the same value.
+@group(0) @binding(2) var input_depth: texture_2d<f32>;
@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>;
@@ -333,7 +335,7 @@ 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);
+    return textureLoad(input_depth, p, 0).r;
 }

@compute @workgroup_size(8, 8)
@@ -12,7 +12,9 @@ struct Params {
 };

@group(0) @binding(0) var<uniform> params: Params;
-@group(0) @binding(1) var depth: texture_depth_2d;
+// A depth view bound as unfilterable float: naga's GLSL backend cannot
+// `textureLoad` a depth texture, and the texel is the same value.
+@group(0) @binding(1) var depth: texture_2d<f32>;
@group(0) @binding(2) var atlas: texture_2d<f32>;
@group(0) @binding(3) var atlas_sampler: sampler;

@@ -38,7 +40,7 @@ struct Out {

 // xy: the motion vector in UV (to where the pixel was last frame, FSR's convention), z: 1.
@fragment fn fs_motion(in: Out) -> @location(0) vec4<f32> {
-    let stored = textureLoad(depth, vec2<i32>(in.clip.xy), 0);
+    let stored = textureLoad(depth, vec2<i32>(in.clip.xy), 0).r;
    let tolerance = stored * 1e-3 + 1e-7;
    // Not what the world shows here: a transparent texel, or behind something.
    if in.translucent != 0u {
@@ -31,6 +31,12 @@
 //! walk's would and a thin shell more, alike on every backend; a frame whose
 //! sums could leave i32 is drawn by the CPU (`Prepared::Cpu`).
 //!
+//! Its statistics, the sections the pass kept and their draws (`counts[0]`,
+//! `counts[1]`), are copied after the pass into one of `READBACKS` small
+//! buffers with the CPU's part of the same frame (`copy_stats`), mapped once the
+//! frame is submitted (`submitted`, from the frame's after-submit hook) and
+//! taken in a frame or a few later (`collect`); nothing waits for them.
+//!
 //! A record also holds where its section's buckets of solid quads by the side
 //! they face end, and what `mesher::Sides::visible_from` compares the eye with
 //! for each, its margin in (`Sides::thresholds`); the tables hold the eye less
@@ -70,9 +76,17 @@ use super::{
    submit::Queue,
    upload::Uploads,
 };
-use crate::mesher::Sides;
-use glam::{DVec3, DVec4, Vec3};
-use std::{cmp::Reverse, collections::BinaryHeap, time::Instant};
+use crate::{graphics::GpuCullingOffer, mesher::Sides};
+use glam::{DVec3, DVec4, Mat4, Vec3};
+use std::{
+    cmp::Reverse,
+    collections::BinaryHeap,
+    sync::{
+        Arc,
+        atomic::{AtomicU8, Ordering},
+    },
+    time::Instant,
+};

 /// One section (`gpu_culling.wgsl`'s `Section`).
 #[repr(C)]
@@ -176,9 +190,9 @@ fn threshold_key(t: f32, positive: bool) -> u32 {
 /// The most draws a section has: the runs its buckets that can face the eye
 /// lie in. Two runs are apart by a bucket left out, so 7 buckets hold at most 4.
 const RUNS: u32 = 4;
-/// Words per id in `runs` (the shader's `RUN_WORDS`): its page and draws, then
-/// each draw's first quad and quads.
-const RUN_WORDS: u64 = 1 + 2 * RUNS as u64;
+/// Words per id in `runs` (the shader's `RUN_WORDS`): its page, flags and draws,
+/// then each draw's first quad and quads, then its two occlusion stamps.
+const RUN_WORDS: u64 = 1 + 2 * RUNS as u64 + 2;

 /// `rounded_box` for bounds past what a box's codes hold, or not finite: no
 /// frustum plane rejects it, so it is drawn wherever its column is within the
@@ -256,15 +270,36 @@ struct Params {
    /// Its height in sections, and the level's (the sky band's top section).
    reach_height: i32,
    reach_sections: i32,
-    /// `REACH`, `SKY`, `EYE`.
+    /// `REACH`, `SKY`, `EYE`, `OCCLUDE`, `PROBE`.
    flags: u32,
    /// With `EYE`, where the eye's keys start in `tables`, in words.
    eyes: u32,
+    /// With `OCCLUDE`: the frame's stamp (never 0), where the boxes to test
+    /// start in `counts`, in words, 0, 0.
+    occl: [u32; 4],
+    /// The world pass's view projection, which the test draws its boxes with.
+    view_proj: [[f32; 4]; 4],
 }

 /// Counts before the pages' (the shader's `STATS`): the sections `cull` kept,
-/// and the draws, fewer only where a region was short.
-const STATS: u64 = 2;
+/// the draws (fewer only where a region was short), then occlusion's: the
+/// quads of the sections with runs and of the tested boxes not seen (the
+/// gate's share), the box draw (its instances: the boxes tested), and the
+/// boxes not seen.
+const STATS: u64 = 12;
+const QUADS: usize = 2;
+const HIDDEN_QUADS: usize = 3;
+const BOX: u64 = 4;
+const HIDDEN: usize = 9;
+/// Statistics on their way back at once, a frame or a few late so the CPU never
+/// waits (as `cull`'s results).
+const READBACKS: usize = 3;
+const FREE: u8 = 0;
+const PENDING: u8 = 1;
+const MAPPED: u8 = 2;
+/// Its mapping failed or the device lost its buffer: never copied into or
+/// unmapped again, so the statistics stop (as `timing::GpuTimer`'s).
+const FAILED: u8 = 3;
 /// In `Params::flags` (the shader's `REACH`): cave culling's graph is in
 /// `reach`.
 const REACH: u32 = 1;
@@ -274,6 +309,10 @@ const SKY: u32 = 2;
 /// In `Params::flags` (the shader's `EYE`): solid quads facing away from the
 /// eye are left out, its keys in `tables` from `Params::eyes`.
 const EYE: u32 = 4;
+/// In `Params::flags` (the shader's `OCCLUDE` and `PROBE`): the frame occludes,
+/// and it tests every box (cull.rs's probe frame).
+const OCCLUDE: u32 = 8;
+const PROBE: u32 = 16;
 /// Ids per block (the shader's `BLOCK`), and the workgroup of the passes over ids.
 const WORKGROUP: u32 = 64;
 /// Workgroups along x when there are more (the shader's `ROW`).
@@ -314,6 +353,11 @@ pub(super) struct FrameInputs<'a> {
    /// from it are left out (`sides_on`); `None`: every solid quad is drawn. A
    /// GPU frame has no water mirror, whose eye below would see more of them.
    pub eye: Option<Vec3>,
+    /// The world pass's view projection (gfx.rs `globals.view_proj`), and
+    /// whether occlusion culling is on: frames that can run its test then
+    /// do, by its gate (`GpuCulling::occluding`).
+    pub view_proj: Mat4,
+    pub occlude: bool,
 }

 /// What `GpuCulling::prepare` made of a frame.
@@ -475,10 +519,31 @@ pub(super) fn supported(
        // The pass binds 8, the last cave culling's graph.
        && limits.max_storage_buffers_per_shader_stage >= 8
        && !super::flat::is_broken_intel_vulkan(info)
-        // DX12's count draws leave each draw's base vertex out of `vertex_index`, by which the
-        // pulled solid pipelines (those of a device with flat page groups) read the page.
-        // shortcut: not offered there, until GPU culling's draws carry their base vertex otherwise.
-        && !(info.backend == wgpu::Backend::Dx12 && flat_min_sections.is_some())
+        && !loses_base_vertex(info, flat_min_sections.is_some())
+}
+
+/// DX12's count draws leave each draw's base vertex out of `vertex_index`, by which the
+/// pulled solid pipelines (those of a device with flat page groups) read the page.
+/// shortcut: not offered there, until GPU culling's draws carry their base vertex otherwise.
+pub(super) fn loses_base_vertex(info: &wgpu::AdapterInfo, flat_page_groups: bool) -> bool {
+    info.backend == wgpu::Backend::Dx12 && flat_page_groups
+}
+
+/// What the settings offer (`graphics::GpuCullingOffer`): where `supported`
+/// holds, but not on a software adapter (WARP, lavapipe), whose pass would run
+/// on the CPU beside the frame, as occlusion culling's default has it; where it
+/// doesn't, DX12 with flat page groups says why (`loses_base_vertex`).
+pub(super) fn offer(
+    info: &wgpu::AdapterInfo,
+    supported: bool,
+    flat_page_groups: bool,
+) -> GpuCullingOffer {
+    match (supported, super::is_software(info.device_type)) {
+        (false, _) if loses_base_vertex(info, flat_page_groups) => GpuCullingOffer::Dx12,
+        (false, _) => GpuCullingOffer::Unsupported,
+        (true, true) => GpuCullingOffer::Software,
+        (true, false) => GpuCullingOffer::Offered,
+    }
 }

 /// A buffer that is recreated larger when it must hold more.
@@ -523,6 +588,20 @@ impl Grown {
        self.bytes = size;
        Some(true)
    }
+    /// `reserve`, keeping what the buffer held (`runs`' stamps).
+    fn reserve_keeping(
+        &mut self,
+        device: &wgpu::Device,
+        encoder: &mut wgpu::CommandEncoder,
+        bytes: u64,
+    ) -> Option<bool> {
+        let (old, old_bytes) = (self.buffer.clone(), self.bytes);
+        let made = self.reserve(device, bytes)?;
+        if made {
+            encoder.copy_buffer_to_buffer(&old, 0, &self.buffer, 0, old_bytes);
+        }
+        Some(made)
+    }
 }

 /// The section table as the CPU keeps it, by id, and what changed since
@@ -653,6 +732,7 @@ impl Records {
        self.fading = 0;
    }
    /// The sections with a record.
+    #[cfg(any(test, debug_assertions))]
    pub fn live(&self) -> usize {
        let free: u32 = self.free.iter().map(|word| word.count_ones()).sum();
        self.records.len() - free as usize
@@ -730,6 +810,159 @@ impl Fades {
    }
 }

+/// One GPU frame's statistics on their way back: `counts[..STATS]`, and what
+/// the CPU drew of the same frame.
+struct Readback {
+    buffer: wgpu::Buffer,
+    state: Arc<AtomicU8>,
+    /// Its frame (gfx.rs `frame_serial`), and the CPU's part of its statistics:
+    /// the sections it drew that the pass didn't count, its section draws, and
+    /// every draw call.
+    frame: u64,
+    cpu: [usize; 3],
+    /// Its frame occluded: its counts carry the test's.
+    occluded: bool,
+}
+
+/// The occlusion test (`gpu_occlusion.wgsl`): its boxes' pipeline and bind
+/// group, and phase 2's passes (count2, scan2, scatter2).
+struct BoxTest {
+    pipeline: wgpu::RenderPipeline,
+    layout: wgpu::BindGroupLayout,
+    group: Option<wgpu::BindGroup>,
+    phase2: [wgpu::ComputePipeline; 3],
+}
+
+impl BoxTest {
+    /// `color`: the world pass's colour format. `None` when the device fails to
+    /// make the pipelines: GPU culling then runs without the test.
+    fn new(
+        device: &wgpu::Device,
+        color: wgpu::TextureFormat,
+        compute: &wgpu::BindGroupLayout,
+    ) -> Option<Self> {
+        let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
+        let internal = device.push_error_scope(wgpu::ErrorFilter::Internal);
+        let entry = |binding, visibility, ty| wgpu::BindGroupLayoutEntry {
+            binding,
+            visibility,
+            ty: wgpu::BindingType::Buffer {
+                ty,
+                has_dynamic_offset: false,
+                min_binding_size: None,
+            },
+            count: None,
+        };
+        let storage = |read_only| wgpu::BufferBindingType::Storage { read_only };
+        use wgpu::ShaderStages as S;
+        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("GPU culling occlusion test"),
+            entries: &[
+                entry(0, S::VERTEX_FRAGMENT, wgpu::BufferBindingType::Uniform),
+                entry(9, S::VERTEX, storage(true)),
+                entry(10, S::VERTEX, storage(true)),
+                entry(11, S::FRAGMENT, storage(false)),
+                entry(12, S::VERTEX, storage(true)),
+            ],
+        });
+        let source = [
+            include_str!("gpu_culling.wgsl"),
+            include_str!("gpu_occlusion.wgsl"),
+        ]
+        .concat();
+        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("GPU culling occlusion test"),
+            source: wgpu::ShaderSource::Wgsl(source.into()),
+        });
+        let layouts = [Some(&layout)];
+        let box_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("GPU culling occlusion test"),
+            bind_group_layouts: &layouts,
+            ..Default::default()
+        });
+        // cull.rs's `Early` pipeline: front faces against the world pass's
+        // reversed depth, without writes.
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("GPU culling occlusion test"),
+            layout: Some(&box_layout),
+            vertex: wgpu::VertexState {
+                module: &module,
+                entry_point: Some("vs_box"),
+                compilation_options: Default::default(),
+                buffers: &[],
+            },
+            primitive: wgpu::PrimitiveState {
+                cull_mode: Some(wgpu::Face::Back),
+                ..Default::default()
+            },
+            depth_stencil: Some(wgpu::DepthStencilState {
+                format: wgpu::TextureFormat::Depth32Float,
+                depth_write_enabled: Some(false),
+                depth_compare: Some(wgpu::CompareFunction::GreaterEqual),
+                stencil: Default::default(),
+                bias: Default::default(),
+            }),
+            multisample: Default::default(),
+            fragment: Some(wgpu::FragmentState {
+                module: &module,
+                entry_point: Some("fs_box"),
+                compilation_options: Default::default(),
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: color,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::empty(),
+                })],
+            }),
+            multiview_mask: None,
+            cache: None,
+        });
+        let compute_layouts = [Some(compute)];
+        let compute_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("GPU culling phase 2"),
+            bind_group_layouts: &compute_layouts,
+            ..Default::default()
+        });
+        let phase2 = ["count2", "scan2", "scatter2"].map(|entry| {
+            device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
+                label: Some("GPU culling phase 2"),
+                layout: Some(&compute_layout),
+                module: &module,
+                entry_point: Some(entry),
+                compilation_options: Default::default(),
+                cache: None,
+            })
+        });
+        let internal = pollster::block_on(internal.pop());
+        if let Some(e) = internal.or(pollster::block_on(validation.pop())) {
+            log::warn!("Horizon renderer: GPU culling's occlusion test unavailable ({e})");
+            return None;
+        }
+        Some(Self {
+            pipeline,
+            layout,
+            group: None,
+            phase2,
+        })
+    }
+
+    /// Its bind group: the parameters, then the test list (`counts`), the
+    /// origins, the stamps (`runs`) and the records.
+    fn bind(&self, device: &wgpu::Device, buffers: [&wgpu::Buffer; 5]) -> wgpu::BindGroup {
+        let entries = [0, 9, 10, 11, 12]
+            .into_iter()
+            .zip(buffers)
+            .map(|(binding, buffer)| wgpu::BindGroupEntry {
+                binding,
+                resource: buffer.as_entire_binding(),
+            });
+        device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("GPU culling occlusion test"),
+            layout: &self.layout,
+            entries: &entries.collect::<Vec<_>>(),
+        })
+    }
+}
+
 /// The pass, its buffers and the records it draws from: made when GPU culling
 /// is switched on, dropped when it is switched off.
 pub(super) struct GpuCulling {
@@ -769,12 +1002,28 @@ pub(super) struct GpuCulling {
    /// This frame's updates and table words, kept for their room.
    scratch: Vec<Update>,
    words: Vec<u32>,
+    /// The statistics on their way back (`Readback`), the next one to copy
+    /// into, and this frame's copy.
+    readbacks: Vec<Readback>,
+    next: usize,
+    current: Option<usize>,
+    /// The occlusion test, where the device can run it (Vulkan, with cull.rs's
+    /// test forced early: `Cull::early`).
+    test: Option<BoxTest>,
+    /// Advanced by every frame that may occlude (never 0); the newest share of
+    /// quads the test hid, with its frame; whether this frame occludes; and the
+    /// newest result's boxes not seen and tested.
+    stamp: u32,
+    share: (u64, f32),
+    occluding: bool,
+    hidden: Option<[usize; 2]>,
 }

 impl GpuCulling {
    /// `None` when the device fails to make the pipelines or the memory for the
-    /// buffers is missing (caught, not raised: raised errors are fatal).
-    pub fn new(device: &wgpu::Device) -> Option<Self> {
+    /// buffers is missing (caught, not raised: raised errors are fatal). `test`:
+    /// the world pass's colour format, where frames can run the occlusion test.
+    pub fn new(device: &wgpu::Device, test: Option<wgpu::TextureFormat>) -> Option<Self> {
        let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
        let internal = device.push_error_scope(wgpu::ErrorFilter::Internal);
        let entry = |binding, ty| wgpu::BindGroupLayoutEntry {
@@ -827,7 +1076,24 @@ impl GpuCulling {
            log::warn!("Horizon renderer: GPU culling unavailable ({e})");
            return None;
        }
+        let test = test.and_then(|color| BoxTest::new(device, color, &layout));
        use wgpu::BufferUsages as U;
+        let readbacks = (0..READBACKS)
+            .map(|_| {
+                Some(Readback {
+                    buffer: try_create(
+                        device,
+                        "GPU culling statistics",
+                        STATS * 4,
+                        U::MAP_READ | U::COPY_DST,
+                    )?,
+                    state: Arc::new(AtomicU8::new(FREE)),
+                    frame: 0,
+                    cpu: [0; 3],
+                    occluded: false,
+                })
+            })
+            .collect::<Option<Vec<_>>>()?;
        Some(Self {
            pipelines,
            layout,
@@ -859,7 +1125,8 @@ impl GpuCulling {
                device,
                "GPU culling counts",
                (STATS + 64) * 4,
-                U::STORAGE | U::INDIRECT | U::COPY_DST | TEST_READ,
+                // The counts are copied out for the statistics (`copy_stats`).
+                U::STORAGE | U::INDIRECT | U::COPY_DST | U::COPY_SRC,
            )?,
            draws: Grown::new(
                device,
@@ -873,7 +1140,13 @@ impl GpuCulling {
                1024 * 16,
                U::VERTEX | U::STORAGE | TEST_READ,
            )?,
-            runs: Grown::new(device, "GPU culling runs", 1024 * RUN_WORDS * 4, U::STORAGE)?,
+            // Kept when it grows (`reserve_keeping`): it holds the stamps.
+            runs: Grown::new(
+                device,
+                "GPU culling runs",
+                1024 * RUN_WORDS * 4,
+                U::STORAGE | U::COPY_SRC | U::COPY_DST,
+            )?,
            // Room for render distance 64's graph, 57.5 KB.
            reach: Grown::new(
                device,
@@ -891,6 +1164,15 @@ impl GpuCulling {
            pass_pages: 1,
            scratch: Vec::new(),
            words: Vec::new(),
+            readbacks,
+            next: 0,
+            current: None,
+            test,
+            stamp: 0,
+            // cull.rs's start: culling until a result says otherwise.
+            share: (0, 1.0),
+            occluding: false,
+            hidden: None,
        })
    }

@@ -912,6 +1194,7 @@ impl GpuCulling {
        self.pages.clear();
        self.ids = 0;
        self.n_updates = 0;
+        self.occluding = false;
        self.prepare_buffers(device, queue, uploads, encoder, input)
            .unwrap_or(Prepared::OutOfMemory)
    }
@@ -955,12 +1238,18 @@ impl GpuCulling {
        let pass_pages = self.records.page_sections.len().max(1) as u32;
        // A region has room for every draw of every record on its page.
        let total = RUNS * self.records.page_sections.iter().sum::<u32>();
-        // The statistics, each page's count, then each block's per page.
-        let count_words = STATS + u64::from(pass_pages) * (1 + u64::from(ids.div_ceil(WORKGROUP)));
+        // The statistics, each page's count in both phases, each block's per
+        // page in both phases, then where the test exists the boxes to test.
+        let blocks = u64::from(ids.div_ceil(WORKGROUP));
+        let phase1_end = STATS + u64::from(pass_pages) * (2 + blocks);
+        let tests_at = phase1_end + u64::from(pass_pages) * blocks;
+        let count_words = match self.test {
+            Some(_) => tests_at + u64::from(ids),
+            None => phase1_end,
+        };
        for (buffer, bytes) in [
            (&mut self.updates, self.scratch.len() as u64 * Update::BYTES),
            (&mut self.origins, u64::from(ids) * 16),
-            (&mut self.runs, u64::from(ids) * RUN_WORDS * 4),
            (&mut self.tables, u64::from(regions + 2 * pass_pages) * 4),
            (&mut self.counts, count_words * 4),
            (&mut self.draws, u64::from(total.max(1)) * 20),
@@ -969,6 +1258,12 @@ impl GpuCulling {
                self.group = None;
            }
        }
+        if self
+            .runs
+            .reserve_keeping(device, encoder, u64::from(ids) * RUN_WORDS * 4)?
+        {
+            self.group = None;
+        }
        // A copy of the graph made anew holds none.
        if let Some(r) = &input.reach
            && self.reach.reserve(device, r.bits.len() as u64 * 4)?
@@ -982,6 +1277,16 @@ impl GpuCulling {
        let Some(params) = planes else {
            return Some(Prepared::Cpu);
        };
+        // Occlusion, by cull.rs's gate over the share the newest test hid.
+        let mut occl = 0;
+        if self.test.is_some() && input.occlude {
+            self.stamp = self.stamp.wrapping_add(1).max(1);
+            let (occludes, probe) = super::cull::gate(self.share.1, self.stamp);
+            if occludes && ids > 0 {
+                self.occluding = true;
+                occl = OCCLUDE | if probe { PROBE } else { 0 };
+            }
+        }
        if self.records.all_dirty {
            // The whole table, after it grew or more records changed than
            // updates take (GPU culling switched on in a loaded world, a
@@ -1025,8 +1330,11 @@ impl GpuCulling {
            updates: self.scratch.len() as u32,
            pages: pass_pages,
            regions,
+            occl: [self.stamp, tests_at as u32, 0, 0],
+            view_proj: input.view_proj.to_cols_array_2d(),
            ..params
        };
+        params.flags |= occl;
        if let Some(r) = &input.reach {
            if self.reach_generation != Some(r.generation) {
                // Through the belt: a search lands every few frames while the
@@ -1040,9 +1348,24 @@ impl GpuCulling {
            params.flags |= REACH | if r.sky_reached { SKY } else { 0 };
        }
        uploads.buffer(encoder, &self.params, 0, bytemuck::bytes_of(&params));
-        encoder.clear_buffer(&self.counts.buffer, 0, Some(count_words * 4));
+        // A frame that occludes reads phase 2's blocks too; the boxes to test
+        // are written before they are read.
+        let cleared = if self.occluding { tests_at } else { phase1_end };
+        encoder.clear_buffer(&self.counts.buffer, 0, Some(cleared * 4));
        if self.group.is_none() {
            self.group = Some(self.bind(device));
+            if let Some(test) = &mut self.test {
+                test.group = Some(test.bind(
+                    device,
+                    [
+                        &self.params,
+                        &self.counts.buffer,
+                        &self.origins.buffer,
+                        &self.runs.buffer,
+                        &self.sections.buffer,
+                    ],
+                ));
+            }
        }
        self.ids = ids;
        self.n_updates = params.updates;
@@ -1102,11 +1425,13 @@ impl GpuCulling {
    /// The kept sections' solid draws, a count draw per page, with the quad
    /// indices bound. Leaves the origins at vertex slot 1. `group`: the page's group 1 for
    /// pipelines that read the page themselves (`Flat::page_group`), else none.
+    /// `phase`: 0, or 1 after `compact` in a frame that occludes.
    pub fn draw<'a>(
        &self,
        pass: &mut wgpu::RenderPass<'_>,
        arena: &Arena,
        group: impl Fn(u32) -> Option<&'a wgpu::BindGroup>,
+        phase: u64,
    ) {
        if self.pages.is_empty() {
            return;
@@ -1121,7 +1446,7 @@ impl GpuCulling {
                &self.draws.buffer,
                u64::from(first) * 20,
                &self.counts.buffer,
-                (STATS + u64::from(page)) * 4,
+                (STATS + phase * u64::from(self.pass_pages) + u64::from(page)) * 4,
                size,
            );
        }
@@ -1131,6 +1456,139 @@ impl GpuCulling {
    pub fn draw_calls(&self) -> usize {
        self.pages.len()
    }
+
+    /// Whether the frame occludes (`prepare`): phase 1's `draw`, then `test` in
+    /// its pass, `compact` after it, and phase 2's `draw` in the next pass.
+    pub fn occluding(&self) -> bool {
+        self.occluding
+    }
+
+    /// The boxes the newest test read back did not see and those it tested,
+    /// and the share of quads it hid (cull.rs `Cull::hidden`).
+    pub fn hidden(&self) -> Option<([usize; 2], f32)> {
+        self.hidden.map(|h| (h, self.share.1))
+    }
+
+    /// In the world pass after phase 1's draws: the listed boxes against its
+    /// depth. Leaves the pass's pipeline and group 0 changed.
+    pub fn test(&self, pass: &mut wgpu::RenderPass<'_>) {
+        if let Some(BoxTest {
+            pipeline,
+            group: Some(group),
+            ..
+        }) = &self.test
+            && self.occluding
+        {
+            pass.set_pipeline(pipeline);
+            pass.set_bind_group(0, group, &[]);
+            pass.draw_indirect(&self.counts.buffer, BOX * 4);
+        }
+    }
+
+    /// Between the world passes: phase 2's draws, of the sections the test saw,
+    /// into the regions phase 1 drew from.
+    pub fn compact(&self, encoder: &mut wgpu::CommandEncoder, timing: Option<&mut PassTiming>) {
+        let (Some(test), Some(group)) = (&self.test, &self.group) else {
+            return;
+        };
+        if !self.occluding {
+            return;
+        }
+        let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
+            label: Some("GPU culling phase 2"),
+            timestamp_writes: timing.and_then(|t| t.compute_writes("GPU culling phase 2")),
+        });
+        pass.set_bind_group(0, group, &[]);
+        let [count2, scan2, scatter2] = &test.phase2;
+        let blocks = self.ids.div_ceil(WORKGROUP);
+        pass.set_pipeline(count2);
+        pass.dispatch_workgroups(blocks.min(ROW), blocks.div_ceil(ROW), 1);
+        pass.set_pipeline(scan2);
+        pass.dispatch_workgroups(self.pass_pages, 1, 1);
+        pass.set_pipeline(scatter2);
+        pass.dispatch_workgroups(blocks.min(ROW), blocks.div_ceil(ROW), 1);
+    }
+
+    /// After the frame's world passes (phase 2's counts too), in the same
+    /// encoder: the pass's counts copied out with
+    /// the CPU's part of frame `frame` (`Readback::cpu`), into the next readback
+    /// if it is free. While three frames' are on their way, this one's
+    /// statistics are never shown.
+    pub fn copy_stats(&mut self, encoder: &mut wgpu::CommandEncoder, frame: u64, cpu: [usize; 3]) {
+        let r = &mut self.readbacks[self.next];
+        if r.state.load(Ordering::Acquire) != FREE {
+            return;
+        }
+        encoder.copy_buffer_to_buffer(&self.counts.buffer, 0, &r.buffer, 0, STATS * 4);
+        (r.frame, r.cpu, r.occluded) = (frame, cpu, self.occluding);
+        self.current = Some(self.next);
+    }
+
+    /// The frame's statistics to read back, started by calling it right after
+    /// the frame's submission (gfx's after-submit hook, on the submit thread
+    /// when the frame goes there), as `cull::Cull::submitted`.
+    pub fn submitted(&mut self) -> Option<impl FnOnce() + Send + 'static> {
+        let i = self.current.take()?;
+        let r = &self.readbacks[i];
+        let (buffer, state) = (r.buffer.clone(), r.state.clone());
+        state.store(PENDING, Ordering::Release);
+        self.next = (i + 1) % READBACKS;
+        Some(move || {
+            buffer
+                .slice(..)
+                .map_async(wgpu::MapMode::Read, move |result| {
+                    state.store(
+                        if result.is_ok() { MAPPED } else { FAILED },
+                        Ordering::Release,
+                    );
+                });
+        })
+    }
+
+    /// The statistics that came back, their readbacks freed: the newest
+    /// frame's, as (frame, [sections drawn, section draws, draw calls]), the
+    /// pass's counts added to the CPU's part. Called as a frame starts, so a
+    /// copy no submission took (a frame that failed on the way) is dropped.
+    pub fn collect(&mut self, device: &wgpu::Device) -> Option<(u64, [usize; 3])> {
+        self.current = None;
+        if device.poll(wgpu::PollType::Poll).is_err() {
+            return None;
+        }
+        let mut newest: Option<(u64, [usize; 3])> = None;
+        for r in &self.readbacks {
+            if r.state.load(Ordering::Acquire) != MAPPED {
+                continue;
+            }
+            {
+                let Ok(data) = r.buffer.slice(..).get_mapped_range() else {
+                    // Device loss can destroy a buffer after its mapping
+                    // succeeded; unmapping it would panic (`timing::GpuTimer`).
+                    r.state.store(FAILED, Ordering::Release);
+                    continue;
+                };
+                // The mapping need not be 4-byte aligned: read the words unaligned.
+                let words: [u32; STATS as usize] =
+                    bytemuck::pod_read_unaligned(&data[..STATS as usize * 4]);
+                let [kept, draws] = [words[0], words[1]];
+                // The newest test's share, for the gate (`prepare`).
+                if r.occluded && r.frame > self.share.0 {
+                    let quads = words[QUADS].max(1);
+                    self.share = (r.frame, words[HIDDEN_QUADS] as f32 / quads as f32);
+                    self.hidden = Some([words[HIDDEN] as usize, words[BOX as usize + 1] as usize]);
+                }
+                let [sections, cpu_draws, calls] = r.cpu;
+                if newest.is_none_or(|(frame, _)| r.frame > frame) {
+                    newest = Some((
+                        r.frame,
+                        [sections + kept as usize, cpu_draws + draws as usize, calls],
+                    ));
+                }
+            }
+            r.buffer.unmap();
+            r.state.store(FREE, Ordering::Release);
+        }
+        newest
+    }
 }

 #[cfg(test)]
@@ -1231,6 +1689,8 @@ mod tests {
            frustum,
            reach: None,
            eye: None,
+            view_proj: Mat4::IDENTITY,
+            occlude: false,
        }
    }

@@ -1393,6 +1853,21 @@ mod tests {
        runs
    }

+    /// The pass's module validates without the early depth test, and the
+    /// occlusion test's (the pass's with `gpu_occlusion.wgsl`) with it.
+    #[test]
+    fn the_shaders_validate() {
+        use naga::valid::Capabilities as C;
+        let pass = include_str!("gpu_culling.wgsl");
+        let test = [pass, include_str!("gpu_occlusion.wgsl")].concat();
+        for (source, capabilities) in [(pass, C::all() - C::EARLY_DEPTH_TEST), (&test, C::all())] {
+            let module = naga::front::wgsl::parse_str(source).unwrap();
+            naga::valid::Validator::new(naga::valid::ValidationFlags::all(), capabilities)
+                .validate(&module)
+                .unwrap();
+        }
+    }
+
    /// Ids, page counts, flags and changes against a plain list of what each id
    /// holds: the lowest free id comes back, flagged only if inserted so, free
    /// ids at the end leave, counts follow moves (to pages past the last too), a
@@ -1631,6 +2106,8 @@ mod tests {
            ("reach_sections", offset_of!(Params, reach_sections)),
            ("flags", offset_of!(Params, flags)),
            ("eyes", offset_of!(Params, eyes)),
+            ("occl", offset_of!(Params, occl)),
+            ("view_proj", offset_of!(Params, view_proj)),
        ] {
            assert!(members.contains(&(name.into(), offset)), "Params.{name}");
        }
@@ -1651,7 +2128,7 @@ mod tests {
        ];
        assert_eq!(layout("Update"), (size_of::<Update>(), named(&id)));
        assert_eq!((size_of::<Record>(), size_of::<Update>()), (80, 96));
-        assert_eq!(size_of::<Params>(), 128);
+        assert_eq!(size_of::<Params>(), 208);
        let constant = |name: &str| {
            let (_, c) = module
                .constants
@@ -2339,7 +2816,7 @@ mod tests {
        // So have the sections' buckets and whether a frame has an eye.
        let mut shapes = Rng(0x3C6E_F372_FE94_F82B);
        let (min_y, height) = (-64, 24);
-        let mut gpu = GpuCulling::new(device).expect("the pass");
+        let mut gpu = GpuCulling::new(device, None).expect("the pass");
        let mut uploads = Uploads::new(device);
        let mut held: BTreeMap<u32, (Placed, Sides)> = BTreeMap::new();
        // Fading sections the frustum and the graph keep, left to the CPU.
@@ -2512,6 +2989,8 @@ mod tests {
                frustum: &frustum,
                reach,
                eye,
+                view_proj: Mat4::IDENTITY,
+                occlude: false,
            };
            if case == 7 {
                // Planes past the integers: the CPU draws that frame, nothing is
@@ -2581,8 +3060,12 @@ mod tests {
                }
            }
            gpu.dispatch(&mut encoder, None);
+            // Its statistics come back with a CPU part of the case's own.
+            let cpu = [case * 7, case * 3, case];
+            gpu.copy_stats(&mut encoder, case as u64, cpu);
            uploads.finish(&encoder);
            queue.submit([encoder.finish()]);
+            gpu.submitted().expect("a readback free")();
            let pages = u64::from(gpu.pass_pages);
            let counts = read(device, queue, &gpu.counts.buffer, (STATS + pages) * 4);
            let draws = read(device, queue, &gpu.draws.buffer, gpu.draws.bytes);
@@ -2619,6 +3102,13 @@ mod tests {
                [kept_sections, draw_count],
                "case {case}: sections kept, draws"
            );
+            // The reads above waited for the GPU.
+            let (kept, drawn) = (kept_sections as usize, draw_count as usize);
+            assert_eq!(
+                gpu.collect(device),
+                Some((case as u64, [cpu[0] + kept, cpu[1] + drawn, cpu[2]])),
+                "case {case}: statistics"
+            );
            compared += kept_sections as usize;
        }
        // Not a comparison of empty lists, nor of a test that keeps everything.
@@ -2645,6 +3135,73 @@ mod tests {
        );
    }

+    /// The statistics come back with their frame, in place and from the submit
+    /// thread, submitted as gfx.rs submits frames (`submit_later`, or in place
+    /// with its `after` handed back): three frames on their way fill the ring, a
+    /// fourth's are skipped, `collect` takes in the newest; and a readback whose
+    /// buffer the device lost after its mapping goes `FAILED`, never copied into
+    /// or unmapped again (as `timing::GpuTimer`'s), so the statistics stop.
+    #[test]
+    fn the_statistics_come_back_with_their_frame() {
+        use super::super::submit::{AfterSubmit, Job};
+        on_each_device(|device, queue| {
+            for threaded in [false, true] {
+                let queue = Queue::new((**queue).clone(), threaded);
+                let mut gpu = GpuCulling::new(device, None).expect("the pass");
+                // As if the pass kept 5 sections and drew 7 times.
+                queue.write_buffer(&gpu.counts.buffer, 0, bytemuck::cast_slice(&[5_u32, 7]));
+                // Whether the frame's statistics went out.
+                let frame = |gpu: &mut GpuCulling, f: u64| {
+                    let mut encoder = device.create_command_encoder(&Default::default());
+                    gpu.copy_stats(&mut encoder, f, [f as usize, 10, 3]);
+                    let after = gpu.submitted().map(|g| Box::new(g) as AfterSubmit);
+                    let sent = after.is_some();
+                    let job = Job {
+                        encoder,
+                        surface: None,
+                        after,
+                    };
+                    if let Err(back) = queue.submit_later(job) {
+                        queue.submit([back.encoder.finish()]);
+                        if let Some(read) = back.after {
+                            read();
+                        }
+                    }
+                    sent
+                };
+                let landed = |gpu: &mut GpuCulling| {
+                    queue.landed();
+                    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+                    gpu.collect(device)
+                };
+                for f in 1..=3 {
+                    assert!(frame(&mut gpu, f), "frame {f}, threaded {threaded}");
+                }
+                assert!(!frame(&mut gpu, 4), "a full ring, threaded {threaded}");
+                assert_eq!(landed(&mut gpu), Some((3, [3 + 5, 10 + 7, 3])));
+                assert_eq!(gpu.collect(device), None);
+                assert!(frame(&mut gpu, 5));
+                assert_eq!(landed(&mut gpu), Some((5, [5 + 5, 10 + 7, 3])));
+                // Frame 6's buffer destroyed after its mapping (#6320).
+                let lost = gpu.next;
+                assert!(frame(&mut gpu, 6));
+                queue.landed();
+                device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+                gpu.readbacks[lost].buffer.destroy();
+                assert_eq!(gpu.collect(device), None);
+                for f in 7..=12 {
+                    let sent = frame(&mut gpu, f);
+                    let back = landed(&mut gpu);
+                    let state = gpu.readbacks[lost].state.load(Ordering::Acquire);
+                    assert_eq!(state, FAILED, "frame {f}, threaded {threaded}");
+                    // The two other readbacks, then none.
+                    assert_eq!(sent, f <= 8, "frame {f}, threaded {threaded}");
+                    assert_eq!(back.is_some(), f <= 8, "frame {f}, threaded {threaded}");
+                }
+            }
+        });
+    }
+
    /// `draw`'s count draws draw what the pass kept, page by page: each kept
    /// section's quads from its own range, all of them without an eye and those
    /// of its runs that can face one with it, with its own origin, which the
@@ -2687,7 +3244,7 @@ struct Quad {
        for _ in 0..4 {
            assert!(arena.open_page(device, u64::from(SECTIONS / 3) * grain));
        }
-        let mut gpu = GpuCulling::new(device).expect("the pass");
+        let mut gpu = GpuCulling::new(device, None).expect("the pass");
        let mut rng = Rng(0x9E37_79B9_7F4A_7C15);
        // The sections' buckets by facing side have their own sequence.
        let mut shapes = Rng(0xA54F_F53A_5F1D_36F1);
@@ -2816,6 +3373,8 @@ struct Quad {
                frustum,
                reach: None,
                eye,
+                view_proj: Mat4::IDENTITY,
+                occlude: false,
            };
            let prepared = gpu.prepare(device, queue, &mut uploads, &mut encoder, &input);
            assert_eq!(prepared, Prepared::Gpu, "frame {frame}");
@@ -2860,7 +3419,7 @@ struct Quad {
            });
            pass.set_pipeline(&pipeline);
            pass.set_index_buffer(indices.slice(..), wgpu::IndexFormat::Uint32);
-            gpu.draw(&mut pass, &arena, |_| None);
+            gpu.draw(&mut pass, &arena, |_| None, 0);
            drop(pass);
            encoder.copy_texture_to_buffer(
                target.as_image_copy(),
@@ -13,6 +13,13 @@
 // integers the CPU computed, and facing compares keys that order as the floats
 // the CPU compares. `cull` leaves sections fading in or out to the CPU
 // (`FADING`).
+// Frames that occlude (`OCCLUDE`, gpu_occlusion.wgsl) draw in two phases, each
+// in id order: `cull` leaves to phase 2 the sections whose box the last test
+// did not see and lists the boxes to test; after the test, `count2`, `scan2`
+// and `scatter2` write the draws of those it saw into the same regions. Which
+// boxes count as seen untested (`near_or_big`) is float arithmetic of the
+// shader's own: it only sorts sections between the phases, and doubt counts as
+// seen.

 struct Params {
    // Ids to test, records `apply` writes, the arena pages the counts and
@@ -34,13 +41,19 @@ struct Params {
    // Each frustum plane's w term, its margin in, then 0, 0.
    w: array<vec4<i32>, 2>,
    // Cave culling's graph (occlusion.rs `Reach`): from x, from z, radius, lowest
-    // section y; its height in sections and the level's; REACH, SKY and EYE;
-    // where the eye's keys start in `tables`.
+    // section y; its height in sections and the level's; REACH, SKY, EYE,
+    // OCCLUDE and PROBE; where the eye's keys start in `tables`.
    reach: vec4<i32>,
    reach_height: i32,
    reach_sections: i32,
    flags: u32,
    eyes: u32,
+    // Occlusion (OCCLUDE): this frame's stamp (never 0), where the boxes to
+    // test start in `counts`, 0, 0.
+    occl: vec4<u32>,
+    // The world pass's view projection, TAA's jitter included (gfx.rs
+    // `globals.view_proj`).
+    view_proj: mat4x4<f32>,
 }

 // gpu_culling.rs `Record`.
@@ -75,15 +88,18 @@ struct Update {
 // and its size).
@group(0) @binding(2) var<storage, read> tables: array<u32>;
@group(0) @binding(3) var<storage, read> updates: array<Update>;
-// Sections kept, draws, each page's draws, then per block of ids and page its
-// draws (`cull`), turned into where they start (`scan`).
+// The statistics (`STATS`), each page's draws in phase 1 and in phase 2, then
+// per block of ids and page its draws in each phase (`cull`, `count2`), turned
+// into where they start (`scan`, `scan2`), then the boxes to test (`cull`).
@group(0) @binding(4) var<storage, read_write> counts: array<atomic<u32>>;
 // DrawIndexedIndirectArgs, five words each.
@group(0) @binding(5) var<storage, read_write> draws: array<u32>;
 // Per id the instance it is drawn with: origin and UV step, as f32 bits.
@group(0) @binding(6) var<storage, read_write> origins: array<vec4<u32>>;
-// Per id `RUN_WORDS`: its page << PAGE_SHIFT | its draws when it is drawn this
-// frame, else 0; then each draw's first quad and quads.
+// Per id `RUN_WORDS`: its page << PAGE_SHIFT | TESTED | PHASE2 | its draws when
+// it is drawn this frame, else 0; then each draw's first quad and quads; then
+// the stamps of the frames whose test last saw its box and last tested it,
+// kept from frame to frame.
@group(0) @binding(7) var<storage, read_write> runs: array<u32>;
 // occlusion.rs `Reach::bits`: whether the search reached each cell of its box,
 // a bit each (32 a word, lowest first).
@@ -95,8 +111,16 @@ const STEP_BITS: u32 = 0x38000000u;
 const ROW: u32 = 65535u;
 // Ids per block.
 const BLOCK: u32 = 64u;
-// Counts before the pages'.
-const STATS: u32 = 2u;
+// Counts before the pages': sections kept and draws, then occlusion's: the
+// quads of the sections with runs and those of the tested boxes not seen, the
+// box draw (four words and a spare), those boxes, phase 2's draws, a spare.
+const STATS: u32 = 12u;
+const DRAWS: u32 = 1u;
+const QUADS: u32 = 2u;
+const HIDDEN_QUADS: u32 = 3u;
+const BOX: u32 = 4u;
+const HIDDEN: u32 = 9u;
+const DRAWN2: u32 = 10u;
 // gpu_culling.rs `rounded_box` for a box past what its codes hold: no plane
 // rejects it.
 const UNBOUNDED: u32 = 0x80000000u;
@@ -109,14 +133,56 @@ const FADING: u32 = 1u;
 // In `params.flags`: solid quads facing away from the eye are left out, its
 // keys in `tables` from `params.eyes`.
 const EYE: u32 = 4u;
-// Words per id in `runs`, and where its page starts in the first, its draws
-// (at most 4: gpu_culling.rs `RUNS`) below.
-const RUN_WORDS: u32 = 9u;
-const PAGE_SHIFT: u32 = 3u;
+// Words per id in `runs`, and where its page starts in the first, its flags and
+// draws (at most 4: gpu_culling.rs `RUNS`) below.
+const RUN_WORDS: u32 = 11u;
+const PAGE_SHIFT: u32 = 5u;
+// In its first word: its box is tested this frame; it waits for phase 2.
+const TESTED: u32 = 16u;
+const PHASE2: u32 = 8u;
+// Its stamps: the frames whose test last saw its box, and last tested it.
+const SEEN_WORD: u32 = 9u;
+const TESTED_WORD: u32 = 10u;
+// In `params.flags`: the frame occludes, and tests every box (cull.rs's probe).
+const OCCLUDE: u32 = 8u;
+const PROBE: u32 = 16u;
+// cull.rs `RETEST` and `BIG`.
+const RETEST: u32 = 8u;
+const BIG: f32 = 0.25;
+// gpu_culling.rs `CODE_OFFSET`: the rounded box's codes hold -8..=23.
+const CODE_OFFSET: i32 = 8i;
+// Past the box, for rounding: far past what f32 moves a camera-relative corner.
+const EPS: f32 = 0.015625;
+// Clip z / w at about twice the near plane's distance: reversed depth is 1 at
+// the near plane and grows toward the eye; behind it, z > 0 >= w.
+const NEAR_DEPTH: f32 = 0.5;

-// The count of `block`'s draws in `page` (`cull`), then where they start (`scan`).
-fn block_count(block: u32, page: u32) -> u32 {
-    return STATS + params.pages + block * params.pages + page;
+// `page`'s count draw in `phase` (0: the first world pass; 1: after the test).
+fn page_count(page: u32, phase: u32) -> u32 {
+    return STATS + phase * params.pages + page;
+}
+
+// The count of `block`'s draws in `page` and `phase` (`cull`, `count2`), then
+// where they start (`scan`): phase 1's slots, then phase 2's.
+fn block_count(block: u32, page: u32, phase: u32) -> u32 {
+    let blocks = (params.ids + BLOCK - 1u) / BLOCK;
+    return STATS + 2u * params.pages + (phase * blocks + block) * params.pages + page;
+}
+
+// The id's first `runs` word, its flags cleared, if it draws in `phase` (in
+// phase 2, only once this frame's test saw its box); else 0.
+fn drawn_in(id: u32, phase: u32) -> u32 {
+    if id >= params.ids {
+        return 0u;
+    }
+    let w = runs[id * RUN_WORDS];
+    if (w & 7u) == 0u || ((w & PHASE2) != 0u) != (phase == 1u) {
+        return 0u;
+    }
+    if (w & PHASE2) != 0u && runs[id * RUN_WORDS + SEEN_WORD] != params.occl.x {
+        return 0u;
+    }
+    return w & ~(PHASE2 | TESTED);
 }

 // `page`'s region of `draws`: its first draw and its size.
@@ -218,6 +284,59 @@ fn seen(id: u32, b: u32, eye: vec3<u32>) -> bool {
    }
 }

+// Corner `c` (bit 0: x, bit 1: y, bit 2: z) of the box tested for the section
+// at `o` whose rounded box is `b` (never UNBOUNDED here): cull.wgsl's box, the
+// cell grown by a block, grown further to the section's own bounds where they
+// reach past it, then by EPS.
+fn box_corner(o: vec3<f32>, b: u32, c: u32) -> vec3<f32> {
+    let low = vec3<i32>(vec3<u32>(b, b >> 5u, b >> 10u) & vec3(31u)) - vec3(CODE_OFFSET);
+    let high = vec3<i32>(vec3<u32>(b >> 15u, b >> 20u, b >> 25u) & vec3(31u)) - vec3(CODE_OFFSET);
+    let lo = min(vec3<f32>(low), vec3(-1.0)) - vec3(EPS);
+    let hi = max(vec3<f32>(high), vec3(17.0)) + vec3(EPS);
+    return o + select(lo, hi, (vec3(c) & vec3(1u, 2u, 4u)) != vec3(0u));
+}
+
+// Boxes that count as seen untested: one with a corner within about twice the
+// near plane's distance, behind the eye, or NaN, whose front faces near
+// clipping could cut away; or, as in cull.wgsl, one over BIG of the screen.
+fn near_or_big(o: vec3<f32>, b: u32) -> bool {
+    var lo = vec2(1e30);
+    var hi = vec2(-1e30);
+    for (var c = 0u; c < 8u; c++) {
+        let p = params.view_proj * vec4(box_corner(o, b, c), 1.0);
+        if !(p.z < NEAR_DEPTH * p.w) {
+            return true;
+        }
+        let q = p.xy / p.w;
+        lo = min(lo, q);
+        hi = max(hi, q);
+    }
+    let size = max(min(hi, vec2(1.0)) - max(lo, vec2(-1.0)), vec2(0.0));
+    return size.x * size.y > BIG * 4.0;
+}
+
+// In frames that occlude, a kept section with runs: its flags (0: phase 1,
+// untested), its box listed when it is tested. Its last test saw it: phase 1,
+// retested every RETEST frames (every frame with PROBE). A box that counts as
+// seen: phase 1. Else phase 2, drawn if this frame's test sees its box.
+fn occlusion(id: u32, at: u32, o: vec3<f32>, b: u32) -> u32 {
+    let stamp = params.occl.x;
+    let seen = runs[at + SEEN_WORD];
+    let passed = seen != 0u && seen == runs[at + TESTED_WORD];
+    if passed && (params.flags & PROBE) == 0u && (id + stamp) % RETEST != 0u {
+        return 0u;
+    }
+    if (b & UNBOUNDED) != 0u || near_or_big(o, b) {
+        runs[at + SEEN_WORD] = stamp;
+        runs[at + TESTED_WORD] = stamp;
+        return 0u;
+    }
+    runs[at + TESTED_WORD] = stamp;
+    let t = atomicAdd(&counts[BOX + 1u], 1u);
+    atomicStore(&counts[params.occl.y + t], id);
+    return TESTED | select(PHASE2, 0u, passed);
+}
+
 // One invocation per changed record; the CPU lists each id once.
@compute @workgroup_size(64)
 fn apply(@builtin(global_invocation_id) gid: vec3<u32>) {
@@ -230,6 +349,10 @@ fn apply(@builtin(global_invocation_id) gid: vec3<u32>) {
@compute @workgroup_size(64)
 fn cull(@builtin(global_invocation_id) gid: vec3<u32>) {
    let id = gid.y * (ROW * BLOCK) + gid.x;
+    if id == 0u && (params.flags & OCCLUDE) != 0u {
+        // The box draw's vertices: the cube's corners (gpu_occlusion.wgsl).
+        atomicStore(&counts[BOX], 36u);
+    }
    // Past the table's end the records are stale: the CPU never writes them free.
    if id >= params.ids {
        return;
@@ -252,7 +375,8 @@ fn cull(@builtin(global_invocation_id) gid: vec3<u32>) {
    atomicAdd(&counts[0], 1u);
    let nx = params.cells.x;
    let ny = params.cells.y;
-    origins[id] = vec4<u32>(tables[c.x], tables[nx + c.y], tables[nx + ny + c.z], STEP_BITS);
+    let origin = vec4<u32>(tables[c.x], tables[nx + c.y], tables[nx + ny + c.z], STEP_BITS);
+    origins[id] = origin;
    // gfx.rs `facing_runs`: the runs of its buckets that can face the eye, an
    // empty bucket breaking none, a draw each; without an eye, its solid quads.
    var n = 0u;
@@ -292,24 +416,29 @@ fn cull(@builtin(global_invocation_id) gid: vec3<u32>) {
    if n == 0u {
        return;
    }
-    runs[at] = (page << PAGE_SHIFT) | n;
-    atomicAdd(&counts[block_count(id / BLOCK, page)], n);
+    var flags = 0u;
+    if (params.flags & OCCLUDE) != 0u {
+        flags = occlusion(id, at, bitcast<vec3<f32>>(origin.xyz), s.a.z);
+    }
+    runs[at] = (page << PAGE_SHIFT) | flags | n;
+    if (flags & PHASE2) == 0u {
+        atomicAdd(&counts[block_count(id / BLOCK, page, 0u)], n);
+    }
 }

 var<workgroup> partial: array<u32, 256>;

 // One workgroup per page: each lane sums a stretch of blocks, the lanes'
-// sums are scanned, and each block's sum becomes where its draws start.
-@compute @workgroup_size(256)
-fn scan(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
-    let page = group.x;
+// sums are scanned, and each block's sum becomes where its draws start, in
+// `phase` (`scan`, gpu_occlusion.wgsl `scan2`).
+fn scan_page(page: u32, lane: u32, phase: u32) {
    let blocks = (params.ids + BLOCK - 1u) / BLOCK;
    let stretch = (blocks + 255u) / 256u;
    let first = min(lane * stretch, blocks);
    let last = min(first + stretch, blocks);
    var sum = 0u;
    for (var b = first; b < last; b++) {
-        sum += atomicLoad(&counts[block_count(b, page)]);
+        sum += atomicLoad(&counts[block_count(b, page, phase)]);
    }
    partial[lane] = sum;
    workgroupBarrier();
@@ -327,31 +456,35 @@ fn scan(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index
        start = partial[lane - 1u];
    }
    for (var b = first; b < last; b++) {
-        let count = atomicLoad(&counts[block_count(b, page)]);
-        atomicStore(&counts[block_count(b, page)], start);
+        let count = atomicLoad(&counts[block_count(b, page, phase)]);
+        atomicStore(&counts[block_count(b, page, phase)], start);
        start += count;
    }
    if lane == 255u {
        // A region has room for every draw of its page's records; were one
        // short, its draws past it go.
        let total = min(partial[255], region(page).y);
-        atomicStore(&counts[STATS + page], total);
-        atomicAdd(&counts[1], total);
+        atomicStore(&counts[page_count(page, phase)], total);
+        atomicAdd(&counts[DRAWS], total);
+        if phase == 1u {
+            atomicAdd(&counts[DRAWN2], total);
+        }
    }
 }

+@compute @workgroup_size(256)
+fn scan(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
+    scan_page(group.x, lane, 0u);
+}
+
 var<workgroup> held: array<u32, 64>;

 // One workgroup per block of ids: each section's draws go after those of the
-// block's earlier sections in its page, in its runs' order.
-@compute @workgroup_size(64)
-fn scatter(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
-    let block = group.y * ROW + group.x;
+// block's earlier sections in its page, in its runs' order, in `phase`
+// (`scatter`, gpu_occlusion.wgsl `scatter2`).
+fn scatter_block(block: u32, lane: u32, phase: u32) {
    let id = block * BLOCK + lane;
-    var mine = 0u;
-    if id < params.ids {
-        mine = runs[id * RUN_WORDS];
-    }
+    let mine = drawn_in(id, phase);
    held[lane] = mine;
    workgroupBarrier();
    // Its draws below PAGE_SHIFT, its page above.
@@ -360,7 +493,7 @@ fn scatter(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_in
        return;
    }
    let page = mine >> PAGE_SHIFT;
-    var slot = atomicLoad(&counts[block_count(block, page)]);
+    var slot = atomicLoad(&counts[block_count(block, page, phase)]);
    for (var other = 0u; other < lane; other++) {
        // A section not drawn holds 0: no draws.
        if (held[other] >> PAGE_SHIFT) == page {
@@ -383,3 +516,8 @@ fn scatter(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_in
        draws[d + 4u] = id;
    }
 }
+
+@compute @workgroup_size(64)
+fn scatter(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
+    scatter_block(group.y * ROW + group.x, lane, 0u);
+}
@@ -0,0 +1,95 @@
+// GPU culling's occlusion test (gpu_culling.rs `BoxTest`), after
+// gpu_culling.wgsl in one module, made only where the depth test can be forced
+// before the fragment shader (Vulkan, cull.rs `DepthTest::Early`): one instance
+// per box `cull` listed, its section's box drawn front faces only against phase
+// 1's depth; then `count2`, `scan2` and `scatter2` write phase 2's draws.
+@group(0) @binding(9) var<storage, read> box_list: array<u32>;
+@group(0) @binding(10) var<storage, read> box_origins: array<vec4<u32>>;
+@group(0) @binding(11) var<storage, read_write> box_runs: array<u32>;
+@group(0) @binding(12) var<storage, read> box_sections: array<Section>;
+
+// The corners (bit 0: x, bit 1: y, bit 2: z) of the box's 12 triangles,
+// counter-clockwise seen from outside (cull.wgsl's).
+const CORNERS = array<u32, 36>(
+    0u, 6u, 2u, 0u, 4u, 6u, 1u, 3u, 7u, 1u, 7u, 5u, 0u, 1u, 5u, 0u, 5u, 4u,
+    2u, 7u, 3u, 2u, 6u, 7u, 0u, 3u, 1u, 0u, 2u, 3u, 4u, 5u, 7u, 4u, 7u, 6u,
+);
+
+struct BoxOut {
+    @builtin(position) position: vec4<f32>,
+    @location(0) @interpolate(flat) id: u32,
+}
+
+@vertex
+fn vs_box(@builtin(vertex_index) v: u32, @builtin(instance_index) t: u32) -> BoxOut {
+    let id = box_list[params.occl.y + t];
+    let o = bitcast<vec3<f32>>(box_origins[id].xyz);
+    var out: BoxOut;
+    out.id = id;
+    out.position = params.view_proj * vec4(box_corner(o, box_sections[id].a.z, CORNERS[v]), 1.0);
+    return out;
+}
+
+// Seen at this fragment, which runs only where the depth test passes (forced
+// before it: a fragment that failed would still write). Every writer stores
+// the same stamp.
+@fragment
+@early_depth_test(force)
+fn fs_box(in: BoxOut) -> @location(0) vec4<f32> {
+    let at = in.id * RUN_WORDS + SEEN_WORD;
+    if box_runs[at] != params.occl.x {
+        box_runs[at] = params.occl.x;
+    }
+    return vec4(0.0);
+}
+
+var<workgroup> tally: array<atomic<u32>, 3>;
+
+// After the test, one workgroup per block of ids: the quads of the sections
+// with runs, the tested boxes not seen and their quads, and per page each
+// block's draws that phase 2 makes (`drawn_in`'s condition).
+@compute @workgroup_size(64)
+fn count2(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
+    if lane < 3u {
+        atomicStore(&tally[lane], 0u);
+    }
+    workgroupBarrier();
+    let block = group.y * ROW + group.x;
+    let id = block * BLOCK + lane;
+    if id < params.ids {
+        let at = id * RUN_WORDS;
+        let w = runs[at];
+        let n = w & 7u;
+        if n > 0u {
+            var quads = 0u;
+            for (var k = 0u; k < n; k++) {
+                quads += runs[at + 2u + 2u * k];
+            }
+            atomicAdd(&tally[0], quads);
+            let saw = runs[at + SEEN_WORD] == params.occl.x;
+            if (w & TESTED) != 0u && !saw {
+                atomicAdd(&tally[1], 1u);
+                atomicAdd(&tally[2], quads);
+            }
+            if (w & PHASE2) != 0u && saw {
+                atomicAdd(&counts[block_count(block, w >> PAGE_SHIFT, 1u)], n);
+            }
+        }
+    }
+    workgroupBarrier();
+    if lane == 0u {
+        atomicAdd(&counts[QUADS], atomicLoad(&tally[0]));
+        atomicAdd(&counts[HIDDEN], atomicLoad(&tally[1]));
+        atomicAdd(&counts[HIDDEN_QUADS], atomicLoad(&tally[2]));
+    }
+}
+
+@compute @workgroup_size(256)
+fn scan2(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
+    scan_page(group.x, lane, 1u);
+}
+
+@compute @workgroup_size(64)
+fn scatter2(@builtin(workgroup_id) group: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
+    scatter_block(group.y * ROW + group.x, lane, 1u);
+}
@@ -101,6 +101,11 @@ fn composed() -> Vec<(&'static str, Vec<&'static str>, String)> {
    let entity = crate::overlay::wgsl_constants() + include_str!("../entity.wgsl");
    vec![
        ("entity", vec!["entity.wgsl"], entity.clone()),
+        (
+            "GPU culling occlusion test",
+            vec!["gpu_culling.wgsl", "gpu_occlusion.wgsl"],
+            include_str!("gpu_culling.wgsl").to_owned() + include_str!("gpu_occlusion.wgsl"),
+        ),
        (
            "static entity",
            vec!["entity.wgsl", "static_entity.wgsl"],
@@ -173,7 +173,8 @@ struct HorizonMaterialSolid {
    @location(0) color: vec4<f32>,
    // The surface target's data: `set_surface`'s, then the fragment's depth, which the post
    // stage's `surface_at` compares with the final depth.
-    @location(1) surface: vec4<f32>,
+    // Its four floats' bits (`SURFACE_FORMAT` is an integer format).
+    @location(1) surface: vec4<u32>,
 }
 // What `fs_solid` leaves in the frame's alpha for HDR output, from the sprite before the pack's
 // material: the pack decides the colour, Horizon still knows which pixels are light sources.
@@ -209,7 +210,7 @@ fn horizon_material_solid(in: HorizonMaterialOut) -> HorizonMaterialSolid {
    var out: HorizonMaterialSolid;
    let mark = horizon_material_mark(in, texel);
    out.color = horizon_material_fogged(vec4(color.rgb, mark), in.spherical, in.cylindrical);
-    out.surface = vec4(horizon_surface.xyz, in.clip.z);
+    out.surface = bitcast<vec4<u32>>(vec4(horizon_surface.xyz, in.clip.z));
    return out;
 }
@fragment fn horizon_material_fs_translucent(in: HorizonMaterialOut) -> @location(0) vec4<f32> {
@@ -335,9 +336,12 @@ fn horizon_material_displace(pos: vec3<f32>, uv: vec2<f32>, layer: u32, color: v
 }
 ";

-/// The surface target (the post stage's `scene_surface`): x the normal (two snorm16 in its
-/// bits), y smoothness, z the pack's data, w the fragment's depth.
-pub const SURFACE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba32Float;
+/// The surface target (the post stage's `scene_surface`): the bits of four floats, x the normal
+/// (two snorm16 in its bits), y smoothness, z the pack's data, w the fragment's depth. Stored
+/// as unsigned integers, not `Rgba32Float`: RGBA32UI is colour-renderable on every backend,
+/// where OpenGL (GLES 3 semantics) refuses RGBA32F as a render attachment, and integers keep
+/// the packed normal's bits exact.
+pub const SURFACE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba32Uint;

 /// The terrain shader for the pack's material stage `source`, with its sprite `tags` and
 /// `materials`, and the vertex stage in its module when `vertex`.
@@ -367,6 +367,8 @@ impl NativeFrame {
            distance: None,
            unculled: None,
            every_face: false,
+            view_casters: false,
+            depth_planes: true,
        })
    }

@@ -510,17 +512,36 @@ impl NativeFrame {

    /// 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 = self.next_inputs(frame, size);
+        queue.write_buffer(&self.buffer, 0, bytemuck::bytes_of(&inputs));
+    }
+
+    /// This frame's inputs, moving the eased values and the frame count on.
+    fn next_inputs(&mut self, frame: &Frame, size: [u32; 2]) -> FrameInputs {
+        // Under `HORIZON_STILL` the world's ticks are the clock (`PackInputs::still_ticks`), and
+        // eased values sit at their targets.
+        // A scripted clock (`PackInputs::frame_timing`) comes first, and eased values
+        // move by its delta.
        let now = std::time::Instant::now();
-        let since = self.wetness.1.map_or(0.0, |t| (now - t).as_secs_f32());
+        let timing = frame.pack.frame_timing;
+        // Seconds, frame index, and the seconds eased values move by when not the
+        // measured ones.
+        let (seconds, index, step) = match (timing, frame.pack.still_ticks) {
+            (Some(t), _) => (t.elapsed, t.counter, Some(t.delta)),
+            (None, Some(ticks)) => (
+                (ticks as f32 / 20.0) % 3600.0,
+                ticks as u32,
+                Some(f32::INFINITY),
+            ),
+            (None, None) => (
+                self.start.elapsed().as_secs_f32() % 3600.0,
+                self.frames,
+                None,
+            ),
+        };
+        let since = step.unwrap_or_else(|| 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,
-            self.shadow_camera.as_ref(),
-        );
+        let mut inputs = frame_inputs(frame, size, seconds, index, self.shadow_camera.as_ref());
        inputs.wetness = self.wetness.0;
        if !self.reflects {
            inputs.has_reflection = 0;
@@ -531,8 +552,11 @@ impl NativeFrame {
        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.
+        // A scripted clock's frames follow each other however long one takes to draw.
        match self.last {
-            Some((previous, camera, time)) if (now - time).as_secs_f32() < MAX_FRAME_GAP => {
+            Some((previous, camera, time))
+                if timing.is_some() || (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();
@@ -551,7 +575,12 @@ impl NativeFrame {
            (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;
+        let dt = step.unwrap_or(inputs.delta_time);
+        inputs.delta_time = match (timing, step) {
+            (Some(t), _) => t.delta,
+            (None, Some(_)) => 0.05,
+            (None, None) => inputs.delta_time,
+        };
        for (value, (target, half_life)) in self.eye.iter_mut().zip(targets) {
            *value = eased(*value, target, half_life, dt);
        }
@@ -560,7 +589,7 @@ impl NativeFrame {
        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));
+        inputs
    }

    /// Takes the post stage's pending history reset. It stays pending if post rendering is
@@ -687,7 +716,7 @@ impl NativePost {
            texture_entry(8, float),
            texture_entry(9, wgpu::TextureSampleType::Depth),
            texture_entry(10, float),
-            texture_entry(11, wgpu::TextureSampleType::Float { filterable: false }),
+            texture_entry(11, wgpu::TextureSampleType::Uint),
        ];
        entries.extend(pack_texture_entries(frame.textures.len()));
        entries
@@ -1156,6 +1185,14 @@ pub fn frame_inputs(
            let k = super::native_shadow::distortion(s.distance, s.resolution);
            2.0 * s.distance / s.resolution.max(1) as f32 * (1.0 - k)
        }),
+        // Shader API 0.2's display fields, which 0.1 packs don't declare: SDR's values, also
+        // with HDR on, until HDR output is served for 0.2 packs.
+        hdr: 0,
+        headroom: 1.0,
+        paper_white: 80.0,
+        peak: 80.0,
+        black_level: 0.0,
+        padding: [0; 3],
    }
 }

@@ -1295,6 +1332,48 @@ mod tests {
        assert_eq!(wetness(0.25, 0.25, 5.0), 0.25);
    }

+    /// A scripted clock comes before STILL's ticks, eased values and wetness move by its
+    /// delta, and a long wait between its frames is not a gap that starts them over.
+    #[test]
+    fn a_scripted_clock_drives_time_frame_index_and_eased_values() {
+        use crate::gfx::pack_uniforms::FrameTiming;
+        let Some((device, _)) = device() else {
+            return;
+        };
+        let hud = crate::hud::HudBatch::new([4, 4]);
+        let mut frame = crate::gfx::pack_uniforms::initial_history_tests::frame(&hud);
+        let mut native = NativeFrame::new(&device, None, Vec::new(), Default::default(), None);
+        frame.pack.still_ticks = Some(47_811);
+        frame.pack.eye_light = [0, 15];
+        frame.pack.rain = 1.0;
+        frame.pack.frame_timing = Some(FrameTiming::nth(1, 2000.0));
+        let first = native.next_inputs(&frame, [4, 4]);
+        assert_eq!(
+            (first.time, first.frame_index, first.delta_time),
+            (0.0, 1, 0.0)
+        );
+        // Wetness starts dry, as on a fresh pack; frame 1's delta of 0 leaves it there.
+        assert_eq!((first.eye_light_smooth[1], first.wetness), (1.0, 0.0));
+        assert!(native.take_history_reset());
+        native.last.as_mut().unwrap().2 -= std::time::Duration::from_secs(5);
+        frame.pack.eye_light = [0, 0];
+        frame.pack.frame_timing = Some(FrameTiming::nth(2, 2000.0));
+        let second = native.next_inputs(&frame, [4, 4]);
+        assert_eq!(
+            (second.time, second.frame_index, second.delta_time),
+            (2.0, 2, 2.0)
+        );
+        // Two seconds: the eye light's 2 s half-life halves it, and wetness rises
+        // by 1 - 0.5^(2/30) (a 30 s half-life while it rains harder).
+        assert_eq!(second.eye_light_smooth[1], 0.5);
+        assert!(
+            (second.wetness - 0.045_158_4).abs() < 1e-6,
+            "{}",
+            second.wetness
+        );
+        assert!(!native.take_history_reset());
+    }
+
    fn device() -> Option<(wgpu::Device, wgpu::Queue)> {
        let instance = crate::gfx::test_gpu::instance();
        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
@@ -1547,4 +1626,307 @@ file = \"b.wgsl\"
            "{fourth:?}"
        );
    }
+
+    /// OpenGL refuses `Rgba32Float` as a render attachment (GLES 3 semantics, absent
+    /// `EXT_color_buffer_float`) but always renders to the integer formats, so the surface
+    /// is an integer format, and `surface_at` gets the floats back from the stored bits.
+    #[test]
+    fn the_surface_is_an_integer_target_that_the_post_stage_reads_bit_exact() {
+        assert_eq!(
+            super::super::native_material::SURFACE_FORMAT.sample_type(None, None),
+            Some(wgpu::TextureSampleType::Uint)
+        );
+        let Some((device, queue)) = device() else {
+            return;
+        };
+        let manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.1\"\n\
+            [[post]]\nfile = \"a.wgsl\"\n";
+        // The surface's fields on the colour: normal x, smoothness, data, and 1 when present.
+        let a = "fn post(input: PostInput) -> vec4<f32> {\n    \
+            let s = surface_at(vec2<i32>(input.pixel));\n    \
+            return vec4<f32>(s.normal.x, s.smoothness, s.data, select(0.0, 1.0, s.present));\n}\n";
+        let files = [(MANIFEST, manifest), ("a.wgsl", a)]
+            .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, None, Vec::new(), Default::default(), None);
+        let mut post = NativePost::new(
+            &device,
+            report.stages,
+            &report.manifest,
+            &[],
+            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,
+        });
+        // What the material stage stores, as the bits of floats: the normal +x (octahedral
+        // (1, 0), two snorm16), smoothness 0.75, data 0.25 and the fragment's depth 0.5.
+        let writer = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: None,
+            source: wgpu::ShaderSource::Wgsl(
+                "@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
+                    return vec4<f32>(f32((i << 1u) & 2u) * 2.0 - 1.0, f32(i & 2u) * 2.0 - 1.0, 0.0, 1.0);
+                }
+                @fragment fn fs() -> @location(0) vec4<u32> {
+                    return bitcast<vec4<u32>>(vec4<f32>(
+                        bitcast<f32>(pack2x16snorm(vec2<f32>(1.0, 0.0))), 0.75, 0.25, 0.5));
+                }"
+                .into(),
+            ),
+        });
+        let writer = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: None,
+            layout: None,
+            vertex: wgpu::VertexState {
+                module: &writer,
+                entry_point: Some("vs"),
+                compilation_options: Default::default(),
+                buffers: &[],
+            },
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            fragment: Some(wgpu::FragmentState {
+                module: &writer,
+                entry_point: Some("fs"),
+                compilation_options: Default::default(),
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: super::super::native_material::SURFACE_FORMAT,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            multiview_mask: None,
+            cache: None,
+        });
+        let mut read = |depth_of_world: f64| {
+            let mut encoder = device.create_command_encoder(&Default::default());
+            {
+                let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                    label: None,
+                    color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                        view: &frame.surface_view,
+                        resolve_target: None,
+                        depth_slice: None,
+                        ops: wgpu::Operations {
+                            load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
+                            store: wgpu::StoreOp::Store,
+                        },
+                    })],
+                    ..Default::default()
+                });
+                pass.set_pipeline(&writer);
+                pass.draw(0..3, 0..1);
+            }
+            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::BLACK),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                    view: &depth,
+                    depth_ops: Some(wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(depth_of_world as f32),
+                        store: wgpu::StoreOp::Store,
+                    }),
+                    stencil_ops: None,
+                }),
+                ..Default::default()
+            });
+            post.run(
+                &device,
+                &mut encoder,
+                (&color, &depth, &frame.surface_view),
+                &view,
+                [4, 4],
+                true,
+                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
+        };
+        // Present where the world's depth is the stored one: +x, 0.75, 0.25 as 8-bit. No value
+        // here sits halfway between two 8-bit levels, where drivers round either way.
+        assert_eq!(read(0.5), [255, 191, 64, 255]);
+        // Hidden by something nearer drawn since: the stored values no longer show.
+        assert_eq!(read(0.25), [0, 0, 0, 0]);
+    }
+
+    /// The surface holds float bit patterns, some of which are NaNs (a normal's two snorm16
+    /// can form one). The material stage writes `bitcast<vec4<u32>>(vec4<f32>(..))`; this
+    /// runs that same expression (not the whole material fragment, which needs a full terrain
+    /// pipeline) on bits fed as integers and checks the texture holds them exactly: payloads,
+    /// signs and denormals included.
+    #[test]
+    fn the_surface_keeps_every_bit_of_the_floats_written_through_the_material_stage_bitcast() {
+        let Some((device, queue)) = device() else {
+            return;
+        };
+        let cases: [[u32; 4]; 4] = [
+            [0x7fc0_1234, 0xffbf_ffff, 0x7fff_8001, 0x7f80_0001],
+            [0x8000_0000, 0x0000_0001, 0x007f_ffff, 0x8000_0001],
+            [0xffff_ffff, 0x7f80_0000, 0xff80_0000, 0x3f80_0000],
+            [0x7fff_8001, 0x0000_0000, 0x1234_5678, 0xdead_beef],
+        ];
+        let mut bits = [[0u32; 4]; 16];
+        bits[..4].copy_from_slice(&cases);
+        let inputs = device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: 256,
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        queue.write_buffer(&inputs, 0, bytemuck::cast_slice(&bits));
+        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: None,
+            source: wgpu::ShaderSource::Wgsl(
+                "@group(0) @binding(0) var<uniform> bits: array<vec4<u32>, 16>;
+                @vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
+                    return vec4<f32>(f32((i << 1u) & 2u) * 2.0 - 1.0, f32(i & 2u) * 2.0 - 1.0, 0.0, 1.0);
+                }
+                @fragment fn fs(@builtin(position) p: vec4<f32>) -> @location(0) vec4<u32> {
+                    let v = bitcast<vec4<f32>>(bits[u32(p.y) * 4u + u32(p.x)]);
+                    return bitcast<vec4<u32>>(v);
+                }"
+                .into(),
+            ),
+        });
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: None,
+            layout: None,
+            vertex: wgpu::VertexState {
+                module: &module,
+                entry_point: Some("vs"),
+                compilation_options: Default::default(),
+                buffers: &[],
+            },
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            fragment: Some(wgpu::FragmentState {
+                module: &module,
+                entry_point: Some("fs"),
+                compilation_options: Default::default(),
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: super::super::native_material::SURFACE_FORMAT,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+            }),
+            multiview_mask: None,
+            cache: None,
+        });
+        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: None,
+            layout: &pipeline.get_bind_group_layout(0),
+            entries: &[wgpu::BindGroupEntry {
+                binding: 0,
+                resource: inputs.as_entire_binding(),
+            }],
+        });
+        let surface = texture(
+            &device,
+            super::super::native_material::SURFACE_FORMAT,
+            wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+        );
+        let row = u64::from(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT);
+        let buffer = device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: row * 4,
+            usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        let mut encoder = device.create_command_encoder(&Default::default());
+        {
+            let view = surface.create_view(&Default::default());
+            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: None,
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &view,
+                    resolve_target: None,
+                    depth_slice: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                ..Default::default()
+            });
+            pass.set_pipeline(&pipeline);
+            pass.set_bind_group(0, &group, &[]);
+            pass.draw(0..3, 0..1);
+        }
+        encoder.copy_texture_to_buffer(
+            surface.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),
+                },
+            },
+            surface.size(),
+        );
+        queue.submit([encoder.finish()]);
+        buffer
+            .slice(..)
+            .map_async(wgpu::MapMode::Read, |r| r.unwrap());
+        device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+        let data = buffer.slice(..).get_mapped_range().unwrap().to_vec();
+        buffer.unmap();
+        for (i, expected) in bits.iter().enumerate() {
+            let (x, y) = (i % 4, i / 4);
+            let at = y * row as usize + x * 16;
+            let got: [u32; 4] = std::array::from_fn(|c| {
+                u32::from_ne_bytes(data[at + c * 4..at + c * 4 + 4].try_into().unwrap())
+            });
+            assert_eq!(
+                got.map(|v| format!("{v:08x}")),
+                expected.map(|v| format!("{v:08x}")),
+                "texel {x},{y}"
+            );
+        }
+    }
 }
@@ -159,9 +159,9 @@ const SHADOW_COLOR: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
 /// staying put while the camera walks a `SNAP`-block cell. The map is distorted about its
 /// centre, so a centre that moves with the camera, even by a texel, resamples every shadow but
 /// the nearest each frame and they shimmer; a still one maps the world to the same texels until
-/// the next cell. Its depth starts 256 blocks further toward the light than `shaders/` packs'
-/// (the projection's near plane is at `-near`), so the ground over a deep cave still casts its
-/// shadow, and ends past the build height and the slant across the map below the camera.
+/// the next cell. Its depth starts 356 blocks toward the light (256 further than `shaders/`
+/// packs' default), so the ground over a deep cave still casts its shadow, and ends past the
+/// build height and the slant across the map below the camera.
 pub fn camera(settings: &Settings) -> Shadow {
    Shadow {
        resolution: settings.resolution,
@@ -169,8 +169,8 @@ pub fn camera(settings: &Settings) -> Shadow {
        render_mul: 1.0,
        interval: SNAP,
        euclidean_snap: true,
-        near: 256.0,
-        far: super::pack_uniforms::SHADOW_EYE + 2.0 * settings.distance + 384.0,
+        near: Some(-356.0),
+        far: Some(2.0 * settings.distance + 384.0),
        ..Shadow::default()
    }
 }