Merge pull request #10236 from horizon-rust/fix/launcher-screenshot-memory

🤖 Agent: merging. The screenshot tiles, viewer and background no longer go through GPUI's never-evicted img(path) cache. Two 32k×16k screenshots on Home went from an 8.7 GiB peak to 277 MiB on the desktop. One risk to watch: the 2 s grace lets the budget overflow while more than 256 MiB of tiles is on screen at once (about 280 tiles with Show all), which is bounded by the list itself.
launcher: draw screenshots at their shown size, under a byte budget
2026-11-07 17:21:49 -10:00 · 2026-11-05 21:37:05 +01:00 · 2026-11-05 21:35:43 +01:00 · 2026-11-05 21:20:36 +01:00 · 2026-11-05 21:08:34 +01:00 · 2026-11-05 21:07:51 +01:00
1096 changed files with 109332 additions and 8770 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
@@ -33,6 +35,7 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
 - **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.
+- **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

@@ -1318,6 +1318,7 @@ dependencies = [
 "ab_glyph",
 "bytemuck",
 "chrono",
+ "dunce",
 "flate2",
 "fs4",
 "gilrs",
@@ -1400,6 +1401,7 @@ dependencies = [
 "chrono",
 "flate2",
 "fs4",
+ "getrandom 0.3.4",
 "gilrs",
 "glam",
 "horizon-anticheat",
@@ -1411,6 +1413,7 @@ dependencies = [
 "horizon-client-render",
 "horizon-command",
 "horizon-core",
+ "horizon-cosmetics",
 "horizon-dualsense",
 "horizon-friends",
 "horizon-hdr",
@@ -1715,6 +1718,7 @@ dependencies = [
 "horizon-mcp",
 "horizon-release-sign",
 "horizon-server-files",
+ "horizon-world",
 "libc",
 "p12-keystore",
 "png",
@@ -30,7 +30,7 @@ Minecraft: Java Edition 26.3, rewritten in Rust. Same worlds, same rules, same t

 ## 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.
+Get **the Horizon launcher** from [playhorizon.dev](https://playhorizon.dev) or [the launcher releases](https://github.com/horizon-rust/horizon/releases?q=launcher&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).

@@ -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>

@@ -396,6 +396,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.
@@ -600,16 +610,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
@@ -860,30 +860,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/`.
@@ -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,
    }
@@ -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(
@@ -207,9 +207,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")
    })
@@ -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.
+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:?}");
+    }
 }
@@ -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(
@@ -826,6 +840,25 @@ fn parse_compound(text: &str, i: usize) -> Result<(Tag, usize), PathError> {
 #[cfg(test)]
 mod tests {
    use super::*;
+    #[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}"),
@@ -119,6 +119,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 +155,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 {
@@ -293,6 +314,8 @@ pub const ACTIONS: &[(&str, Option<Button>)] = &[
    ("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),
 ];

 /// How a bindable action reaches the game: one of its own handlers, shared
@@ -454,6 +477,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 +505,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 +573,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),
@@ -568,7 +597,7 @@ impl PadSettings {
    }
    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 +610,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!(
@@ -787,6 +817,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 +1004,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 +1039,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
@@ -1391,7 +1609,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"));
@@ -1437,6 +1657,27 @@ 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 radial_deadzone_rescales() {
        assert_eq!(radial([0.1, 0.05], 0.15), [0.0, 0.0]);
@@ -1581,6 +1822,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 +1895,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 +1924,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");
@@ -23,6 +23,8 @@ pub const MAPPINGS: &[(&str, &str, &str)] = &[
    ("key.pickItem", "key.mouse.middle", "gameplay"),
    ("key.command", "key.keyboard.slash", "multiplayer"),
    ("key.friends", "key.keyboard.o", "multiplayer"),
+    // Horizon's emote wheel (docs/cosmetics.md), on a key vanilla leaves free.
+    ("key.emote", "key.keyboard.b", "multiplayer"),
    ("key.socialInteractions", "key.keyboard.p", "multiplayer"),
    ("key.toggleGui", "key.keyboard.f1", "misc"),
    (
@@ -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.
@@ -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,
@@ -352,6 +352,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");
@@ -208,6 +208,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 +236,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>,
@@ -693,17 +705,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 +806,35 @@ fn cards_changed(seen: Option<&str>, cards: Option<&str>) -> bool {
        _ => true,
    }
 }
+
+/// 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 {
+    #[cfg(target_os = "linux")]
+    {
+        let range = match config.buffer_size() {
+            cpal::SupportedBufferSize::Range { min, max } => (*min, *max),
+            cpal::SupportedBufferSize::Unknown => (256, 4096),
+        };
+        let target = 1024u32.clamp(range.0, range.1);
+        let mut sc = config.config();
+        sc.buffer_size = cpal::BufferSize::Fixed(target);
+        sc
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        config.config()
+    }
+}
+
 #[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 +842,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 +1309,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 +1358,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 +1428,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 +1578,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"));
@@ -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 =
@@ -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;
                }
@@ -3242,6 +3497,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 +3610,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 +3905,7 @@ mod tests {
            skull: &|_| None,
            glyph: &glyph,
            glyphs: 0,
+            dynamic_visible: None,
        };
        let mut call = TextCall {
            matrix: Mat4::IDENTITY,
@@ -3720,6 +3978,7 @@ mod tests {
            skull: &|_| None,
            glyph: &glyph,
            glyphs: 0,
+            dynamic_visible: None,
        };
        let call = TextCall {
            matrix: Mat4::IDENTITY,
@@ -3748,6 +4007,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 +4217,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();
@@ -3975,6 +4358,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 +4444,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);
+}
@@ -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",
@@ -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
@@ -46,7 +46,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 +66,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,
@@ -166,9 +168,17 @@ pub struct Extras {
    pub cosmetics_mine: bool,
    pub cosmetics_others: Option<horizon_cosmetics::prefs::Others>,
    pub cosmetics_auras: 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 +190,7 @@ impl Default for Extras {
    fn default() -> Self {
        Self {
            pack_browser: false,
+            pregen: false,
            fullbright: false,
            dynamic_lights: false,
            zoom: false,
@@ -225,7 +236,10 @@ impl Default for Extras {
            cosmetics_mine: true,
            cosmetics_others: None,
            cosmetics_auras: false,
+            cosmetics_solo: false,
            cosmetics_owner: false,
+            horizon_marks: true,
+            horizon_listed: true,
            three_d_skin_layers: false,
            pvp: Default::default(),
        }
@@ -259,6 +273,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),
@@ -335,6 +350,9 @@ impl Extras {
                        horizon_cosmetics::prefs::Others::parse(value).or(e.cosmetics_others)
                }
                "cosmeticsAuras" => e.cosmetics_auras = flag(e.cosmetics_auras),
+                "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 +363,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:{}\nwheelCyclesSettings:{}\nmusicOff:{}\nmusicPage:{}\ncosmeticsMine:{}\n{}cosmeticsAuras:{}\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),
@@ -399,6 +418,11 @@ impl Extras {
            self.cosmetics_others
                .map_or(String::new(), |o| format!("cosmeticsOthers:{}\n", o.name())),
            bool_text(self.cosmetics_auras),
+            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),
        );
@@ -570,24 +594,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,
+    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 +621,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 +636,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(HorizonMarks),
+            Ok(HorizonMe),
        ]);
    }
    rows
@@ -639,9 +669,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::CosmeticsSolo => "horizon.extras.cosmetics_solo",
+            Item::HorizonMarks => "horizon.extras.horizon_marks",
+            Item::HorizonMe => "horizon.extras.horizon_me",
            Item::Pvp(o) => o.caption_key(),
        }
    }
@@ -668,9 +702,13 @@ impl Item {
            Item::ChatIndicator => "horizon.extras.chat_indicator.tooltip",
            Item::WheelCyclesSettings => "horizon.extras.wheel_cycles_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::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 +744,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::CosmeticsSolo => "In single player",
+            Item::HorizonMarks => "Horizon logos",
+            Item::HorizonMe => "Show me as Horizon",
            Item::Pvp(o) => o.caption(),
        }
    }
@@ -724,7 +766,8 @@ impl Item {
            Fullbright | DynamicLights | OwnNameTag | HideBlockParticles | MouseTweaks | Sort
            | AutoReconnect | NoAi | AgentControl | ReproKeys | DiscordPresence | Splitscreen
            | ChatAnimation | WheelCyclesSettings | MusicPage | PackBrowser | CosmeticsMine
-            | CosmeticsOthers | CosmeticsAuras => {
+            | CosmeticsOthers | CosmeticsAuras | CosmeticsSolo | HorizonMarks | HorizonMe
+            | Pregen => {
                return None;
            }
        })
@@ -732,6 +775,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."
@@ -789,6 +835,15 @@ impl Item {
                "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::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 +870,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::CosmeticsAuras
+            | Item::CosmeticsSolo
+            | Item::HorizonMarks
+            | Item::HorizonMe => Some(Cost::Low),
            _ => None,
        }
    }
@@ -841,7 +901,11 @@ impl Item {
            Item::Splitscreen => e.splitscreen,
            Item::WheelCyclesSettings => e.wheel_cycles_settings,
            Item::PackBrowser => e.pack_browser,
+            Item::Pregen => e.pregen,
            Item::CosmeticsAuras => e.cosmetics_auras,
+            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,6 +960,7 @@ 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.
@@ -903,6 +968,9 @@ impl Item {
                e.cosmetics_others = Some(if back { o.next().next() } else { o.next() });
            }
            Item::CosmeticsAuras => e.cosmetics_auras = !e.cosmetics_auras,
+            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 => {}
        }
@@ -993,7 +1061,7 @@ mod tests {
        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_eq!(Extras::parse(""), d);
@@ -1018,6 +1086,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));
@@ -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),
@@ -451,6 +458,7 @@ mod tests {
            boss_world_fog: false,
            spectator: false,
            fire_resistance: false,
+            full_water_vision: false,
            night_vision: 0.0,
        }
    }
@@ -673,6 +681,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
@@ -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,7 @@ impl NativeFrame {
            distance: None,
            unculled: None,
            every_face: false,
+            view_casters: false,
        })
    }

@@ -510,15 +511,24 @@ 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;
+        // Under `HORIZON_STILL` the world's ticks are the clock (`PackInputs::still_ticks`), and
+        // eased values sit at their targets.
+        let still = frame.pack.still_ticks;
+        let seconds = still.map_or_else(
+            || self.start.elapsed().as_secs_f32() % 3600.0,
+            |ticks| (ticks as f32 / 20.0) % 3600.0,
+        );
        let now = std::time::Instant::now();
-        let since = self.wetness.1.map_or(0.0, |t| (now - t).as_secs_f32());
+        let since = match still {
+            Some(_) => f32::INFINITY,
+            None => 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,
+            still.map_or(self.frames, |ticks| ticks as u32),
            self.shadow_camera.as_ref(),
        );
        inputs.wetness = self.wetness.0;
@@ -551,7 +561,13 @@ 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 = match still {
+            Some(_) => {
+                inputs.delta_time = 0.05;
+                f32::INFINITY
+            }
+            None => inputs.delta_time,
+        };
        for (value, (target, half_life)) in self.eye.iter_mut().zip(targets) {
            *value = eased(*value, target, half_life, dt);
        }
@@ -687,7 +703,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 +1172,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],
    }
 }

@@ -1547,4 +1571,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()
    }
 }
@@ -692,6 +692,25 @@ impl Occlusion {
    pub fn contains(&self, key: SectionKey) -> bool {
        self.graph.as_ref().is_none_or(|g| g.contains(key))
    }
+    /// Whether the current graph knows that `key` is visible from
+    /// `camera_section`. Unknown is returned when the graph is absent, was
+    /// searched from another section, or does not cover the queried section.
+    pub fn visible_for_camera(&self, key: SectionKey, camera_section: SectionKey) -> Option<bool> {
+        let graph = self.graph.as_ref()?;
+        if graph.from != camera_section {
+            return None;
+        }
+        let dx = i64::from(key.0) - i64::from(graph.from.0);
+        let dz = i64::from(key.2) - i64::from(graph.from.2);
+        if dx.abs() > i64::from(graph.radius)
+            || dz.abs() > i64::from(graph.radius)
+            || key.1 < graph.y0
+            || key.1 > graph.sections
+        {
+            return None;
+        }
+        Some(graph.contains(key))
+    }
    /// Changes whenever `contains` may answer differently: a search landed, a
    /// partial update reached more sections, or the graph went.
    #[cfg(any(test, debug_assertions))]
@@ -904,6 +923,77 @@ mod tests {
        assert!(o.contains((2, 1, 0)));
    }

+    /// `visible_for_camera` answers only for the box of the graph it holds, and
+    /// only for the camera that search started from. Everywhere else it says
+    /// unknown, so the caller keeps the geometry.
+    #[test]
+    fn visible_for_camera_is_unknown_outside_its_box_and_its_camera() {
+        // No graph yet: nothing to answer with.
+        assert_eq!(
+            Occlusion::new(0, 4).visible_for_camera((0, 1, 0), (0, 1, 0)),
+            None
+        );
+        let mut o = Occlusion::new(0, 4);
+        o.settle(at((0, 1, 0)), 2);
+        let from = o.columns.section_of(at((0, 1, 0)));
+        assert_eq!(from, (0, 1, 0), "the camera section searched from");
+        // Inside the searched box the answer is `contains`, its edges too.
+        for x in -2..=2 {
+            for z in -2..=2 {
+                for y in -1..=4 {
+                    assert_eq!(
+                        o.visible_for_camera((x, y, z), from),
+                        Some(o.contains((x, y, z))),
+                        "{x} {y} {z}"
+                    );
+                }
+            }
+        }
+        assert_eq!(
+            o.visible_for_camera((2, 1, 0), from),
+            Some(true),
+            "the box's edge"
+        );
+        // Off the box's sides, below it, or above the level: unknown.
+        for key in [
+            (3, 1, 0),
+            (-3, 1, 0),
+            (0, 1, 3),
+            (0, 1, -3),
+            (0, -2, 0),
+            (0, 5, 0),
+        ] {
+            assert_eq!(o.visible_for_camera(key, from), None, "{key:?}");
+        }
+        // Another camera section: this graph is not about it.
+        assert_eq!(o.visible_for_camera((0, 1, 0), (1, 1, 0)), None);
+    }
+
+    /// The answer follows the graph: a closed wall hides the section behind it,
+    /// and opening the wall shows it again.
+    #[test]
+    fn visible_for_camera_reports_what_the_graph_hides() {
+        let mut o = Occlusion::new(0, 4);
+        for (dx, dy, dz) in STEPS {
+            o.set((dx, 1 + dy, dz), 0);
+        }
+        o.settle(at((0, 1, 0)), 3);
+        let from = (0, 1, 0);
+        assert_eq!(
+            o.visible_for_camera((1, 1, 0), from),
+            Some(true),
+            "the wall itself"
+        );
+        assert_eq!(
+            o.visible_for_camera((2, 1, 0), from),
+            Some(false),
+            "hidden behind it"
+        );
+        o.set((1, 1, 0), ALL_VISIBLE);
+        o.settle(at((0, 1, 0)), 3);
+        assert_eq!(o.visible_for_camera((2, 1, 0), from), Some(true));
+    }
+
    /// Faces `a` and `b` of a section see each other, nothing else does.
    fn connects(a: usize, b: usize) -> u64 {
        1 << (a * 6 + b) | 1 << (b * 6 + a)
@@ -519,6 +519,36 @@ const FACE: &str = "    uint hz_q = (uint(gl_VertexIndex) & ~3u) * 6u;\n    \
        }\n    \
    }\n";

+/// `terrain` (`PackAtlas::terrain_inputs`) drawing only solid terrain, then only cutout terrain:
+/// each leaves the other part's quads outside the clip volume. Solid: the quads over opaque
+/// texels and opaque leaves (`mesher::OPAQUE_LAYER`), as vanilla picks `ChunkSectionLayer.SOLID`
+/// per quad (`FaceBakery.computeMaterialTransparency`, `SectionCompiler.compile`), and lava's
+/// faces (sprite layers `lava`, its still and flowing sprites), which Iris 1.11.7 drew with
+/// `gbuffers_terrain_solid` in our probes, with and without `separateAo`.
+///
+/// The test reads only the vertex's sprite layer, which all four vertices of a quad share: a
+/// quad lands whole in one part. The colour's alpha can't decide it, as with `separateAo` it
+/// holds each vertex's own ambient occlusion.
+pub fn terrain_parts(
+    terrain: &horizon_shaders::GbuffersInputs,
+    lava: &[u16],
+) -> [horizon_shaders::GbuffersInputs; 2] {
+    let opaque = crate::mesher::OPAQUE_LAYER;
+    let lava: String = lava
+        .iter()
+        .map(|l| format!(" || hz_v_layer == {l}u"))
+        .collect();
+    let part = |solid: bool| {
+        let mut inputs = terrain.clone();
+        inputs.after.push_str(&format!(
+            "    bool hz_solid = (hz_v_layer & {opaque}u) != 0u{lava};\n    \
+             if (hz_solid != {solid}) gl_Position = vec4(2.0, 2.0, 2.0, 1.0);\n"
+        ));
+        inputs
+    };
+    [part(true), part(false)]
+}
+
 impl PackAtlas {
    /// The vertex inputs of a gbuffers program drawing terrain (`TerrainVertex`, terrain.wgsl's
    /// `vs_terrain` or, for `flat` draws, `vs_terrain_flat`), in atlas coordinates.
@@ -577,12 +607,16 @@ impl PackAtlas {
        } else {
            "1.0"
        };
+        // A vertex's place in its section goes down to the 32768th of a block below it: read back
+        // with a probe pack of ours, Iris 1.11.7's terrain `gl_Vertex` has that for every position
+        // we read (water tops at 8/9 - 0.001, plants' offsets), on all three axes (#8464). A fit,
+        // not Iris's code. Whole and half blocks, and every 1/16, are on that grid already.
        let body = format!(
            "    vec4 hz_origin = {origin};\n    \
             uint hz_layer = hz_v_layer & 32767u;\n    \
             {cell}\
             hz_scale = vec2({:?}, {:?}) * {side};\n    \
-             hz_Vertex = vec4(hz_v_pos + hz_origin.xyz, 1.0);\n    \
+             hz_Vertex = vec4(floor(hz_v_pos * 32768.0) / 32768.0 + hz_origin.xyz, 1.0);\n    \
             hz_uv_scale = hz_origin.w > 0.0 ? uintBitsToFloat(floatBitsToUint(hz_origin.w) & 0xff800000u) : fract(abs(hz_origin.w));\n    \
             hz_mid = vec2(0.5);\n    \
             hz_MultiTexCoord0 = vec4((hz_cell + clamp(vec2(hz_v_uv) * hz_uv_scale, 0.0, 1.0)) * hz_scale, 0.0, 1.0);\n    \
@@ -614,6 +648,13 @@ impl PackAtlas {
            "vec4(0.0)"
        };
        let attributes = [
+            // section_instance stores 1 - visibility in a positive origin's mantissa.
+            // Negative origins encode a distant-terrain handover, fully visible here
+            // just as terrain.wgsl's instance_visibility treats them.
+            (
+                "mc_chunkFade",
+                "(hz_origin.w > 0.0 ? 1.0 - float(floatBitsToUint(hz_origin.w) & 0x7fffffu) / 8388608.0 : 1.0)",
+            ),
            ("mc_Entity", entity),
            ("at_midBlock", mid_block),
            (
@@ -637,10 +678,15 @@ impl PackAtlas {
            after: String::new(),
            alpha_test: None,
            item_id_declared: false,
+            far_depth: false,
        }
    }
 }

+#[cfg(test)]
+#[path = "pack_atlas/fade_test.rs"]
+mod fade_test;
+
 #[cfg(test)]
 #[path = "pack_atlas/midpoint_test.rs"]
 mod midpoint_test;
@@ -0,0 +1,406 @@
+//! Original pack-to-pixel controls of terrain's visibility input, with no external fixture.
+use super::PackAtlas;
+use crate::gfx::{section_instance, section_visibility};
+use crate::mesher::TerrainVertex;
+use std::{
+    path::PathBuf,
+    time::{Duration, Instant},
+};
+use wgpu::util::DeviceExt;
+
+struct ProbePack(PathBuf);
+impl Drop for ProbePack {
+    fn drop(&mut self) {
+        std::fs::remove_dir_all(&self.0).unwrap();
+    }
+}
+
+#[test]
+fn terrain_fade_reaches_pack_pixels_through_real_instances() {
+    let instance = crate::gfx::test_gpu::instance();
+    let adapter = match pollster::block_on(instance.request_adapter(&Default::default())) {
+        Ok(adapter) => adapter,
+        Err(error) => {
+            eprintln!("SKIP terrain fade GPU control: no adapter: {error}");
+            return;
+        }
+    };
+    eprintln!("terrain fade adapter: {:?}", adapter.get_info());
+    let (device, queue) = pollster::block_on(adapter.request_device(&Default::default())).unwrap();
+    let array = device.create_texture(&wgpu::TextureDescriptor {
+        label: None,
+        size: wgpu::Extent3d {
+            width: 2,
+            height: 2,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Rgba8Unorm,
+        usage: wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::TEXTURE_BINDING,
+        view_formats: &[],
+    });
+    let mut encoder = device.create_command_encoder(&Default::default());
+    let mut atlas = PackAtlas::new(&device, &mut encoder, &[array], 1, 1, 2).unwrap();
+    atlas.separate_ao = true;
+    queue.submit([encoder.finish()]);
+    let folder = ProbePack(
+        std::env::temp_dir().join(format!("horizon-terrain-fade-{}", std::process::id())),
+    );
+    std::fs::create_dir_all(folder.0.join("shaders")).unwrap();
+    // The guard, initializer, varying and integer output are independent probe code.
+    let vertex = "#version 330\nout vec4 observation;\n\
+        #ifdef IRIS_FEATURE_FADE_VARIABLE\nfloat first = mc_chunkFade;\n#endif\n\
+        void main() {\n#ifdef IRIS_FEATURE_FADE_VARIABLE\n\
+        observation = vec4(mc_chunkFade, first, gl_Color.a, gl_MultiTexCoord0.x);\n\
+        #else\nobservation = vec4(1.0, 1.0, gl_Color.a, gl_MultiTexCoord0.x);\n#endif\n\
+        gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n}";
+    let fragment = "#version 330\nin vec4 observation;\nlayout(location = 0) out uvec4 pixel;\n\
+        void main() { pixel = floatBitsToUint(observation); }";
+    let geometry_vertex = vertex
+        .replace("float first = mc_chunkFade;", "")
+        .replace("mc_chunkFade, first,", "mc_chunkFade, mc_chunkFade,")
+        .replace("observation", "vertex_observation");
+    let geometry_shader = "#version 330\nlayout(triangles) in;\n\
+        layout(triangle_strip, max_vertices=3) out;\nin vec4 vertex_observation[];\n\
+        out vec4 observation;\nconst float mc_chunkFade = 0.8125;\nvoid main() {\n\
+        for (int k=0; k<3; ++k) {\nobservation = vertex_observation[k];\n\
+        observation.y = mc_chunkFade;\n\
+        gl_Position = vec4(k == 1 ? 3.0 : -1.0, k == 2 ? 3.0 : -1.0, 0.0, 1.0);\n\
+        EmitVertex();\n}\nEndPrimitive();\n}";
+    for name in ["gbuffers_terrain", "gbuffers_water", "shadow"] {
+        for (extension, code) in [("vsh", vertex), ("fsh", fragment)] {
+            std::fs::write(folder.0.join(format!("shaders/{name}.{extension}")), code).unwrap();
+        }
+    }
+    let uploaded = Instant::now();
+    let cases = [
+        ("first frame", Some(&uploaded), 0, 1000, 0, 0.0),
+        ("137ms", Some(&uploaded), 137, 1000, 0, 0.137),
+        ("midpoint", Some(&uploaded), 500, 1000, 0, 0.5),
+        ("finished", Some(&uploaded), 1000, 1000, 0, 1.0),
+        ("disabled", Some(&uploaded), 0, 0, 0, 1.0),
+        ("no upload transition", None, 0, 1000, 0, 1.0),
+        ("distant handover", Some(&uploaded), 500, 1000, 17, 1.0),
+    ];
+    let mut count = 0;
+    for requested in [false, true] {
+        std::fs::write(
+            folder.0.join("shaders/shaders.properties"),
+            if requested {
+                "shadow.enabled=true\niris.features.optional=FADE_VARIABLE\niris.features.required=FADE_VARIABLE\n"
+            } else {
+                "shadow.enabled=true\n"
+            },
+        )
+        .unwrap();
+        let pack = horizon_shaders::Pack::open(&folder.0).unwrap();
+        let mut macros = horizon_shaders::Macros::standard();
+        let (properties, notes) = horizon_shaders::read_properties(&pack, &mut macros);
+        assert!(notes.is_empty(), "{notes:?}");
+        for flat in [false, true] {
+            for geometry in [false, true].into_iter().filter(|g| !*g || flat) {
+                let geometry_path = folder.0.join("shaders/shadow.gsh");
+                if geometry {
+                    std::fs::write(&geometry_path, geometry_shader).unwrap();
+                } else if geometry_path.exists() {
+                    std::fs::remove_file(&geometry_path).unwrap();
+                }
+                std::fs::write(
+                    folder.0.join("shaders/shadow.vsh"),
+                    if geometry {
+                        geometry_vertex.as_str()
+                    } else {
+                        vertex
+                    },
+                )
+                .unwrap();
+                let post = horizon_shaders::load_post(
+                    &pack,
+                    "",
+                    &properties,
+                    &macros,
+                    &horizon_shaders::GameInputs {
+                        terrain: Some(atlas.terrain_inputs(flat)),
+                        terrain_geometry: geometry.then(|| horizon_shaders::GeometryInputs {
+                            inputs: atlas.terrain_inputs(true),
+                            pull: super::PULL.to_owned(),
+                            index: "@".to_owned(),
+                        }),
+                        ..Default::default()
+                    },
+                );
+                for (name, program) in [
+                    ("terrain", &post.terrain),
+                    ("water", &post.water),
+                    ("shadow", &post.shadow),
+                ] {
+                    if geometry && name != "shadow" {
+                        continue;
+                    }
+                    let program = program
+                        .as_ref()
+                        .unwrap_or_else(|| panic!("{name}: {:?}", post.notes));
+                    for &(case, timestamp, elapsed, fade_ms, handover, expected) in &cases {
+                        let visibility = section_visibility(
+                            timestamp,
+                            fade_ms,
+                            uploaded + Duration::from_millis(elapsed),
+                        );
+                        let origin = section_instance([48.0, 0.0, -16.0], handover, visibility);
+                        let pixel = sample(
+                            &device,
+                            &queue,
+                            &atlas,
+                            program.program.as_ref().unwrap(),
+                            flat,
+                            geometry,
+                            origin,
+                        );
+                        let fade = if requested { expected } else { 1.0 };
+                        let expected = [
+                            fade,
+                            if geometry { 0.8125 } else { fade },
+                            128.0 / 255.0,
+                            0.25,
+                        ];
+                        assert!(
+                            pixel
+                                .iter()
+                                .zip(expected)
+                                .all(|(a, b)| a.is_finite() && (a - b).abs() < 2e-7),
+                            "{name} {case} flat={flat} geometry={geometry} requested={requested}: {pixel:?} != {expected:?}"
+                        );
+                        count += 1;
+                    }
+                }
+            }
+        }
+    }
+    eprintln!("terrain fade pack-to-pixel cases executed: {count}");
+    assert_eq!(count, 98);
+}
+
+fn sample(
+    device: &wgpu::Device,
+    queue: &wgpu::Queue,
+    atlas: &PackAtlas,
+    program: &horizon_shaders::Program,
+    flat: bool,
+    geometry: bool,
+    origin: [f32; 4],
+) -> [f32; 4] {
+    let buffer = |bytes: &[u8], usage| {
+        device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: None,
+            contents: bytes,
+            usage,
+        })
+    };
+    let uniform = buffer(
+        &vec![0; program.interface.uniform_size as usize],
+        wgpu::BufferUsages::UNIFORM,
+    );
+    let origins = buffer(
+        bytemuck::bytes_of(&origin),
+        wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::VERTEX,
+    );
+    let slots = buffer(bytemuck::bytes_of(&0u32), wgpu::BufferUsages::STORAGE);
+    let vertices: Vec<_> = [[0., 0., 0.], [1., 0., 0.], [1., 1., 0.], [0., 1., 0.]]
+        .into_iter()
+        .map(|pos| TerrainVertex::new(pos, [0.25, 0.75], 0, 0x80ffffff, 0))
+        .collect();
+    let data = buffer(
+        bytemuck::cast_slice(&vertices),
+        wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::VERTEX,
+    );
+    let ids = buffer(bytemuck::bytes_of(&[0i32; 3]), wgpu::BufferUsages::STORAGE);
+    let rects = buffer(
+        bytemuck::cast_slice(&atlas.rects_table()),
+        wgpu::BufferUsages::STORAGE,
+    );
+    let binding = |n, storage| wgpu::BindGroupLayoutEntry {
+        binding: n,
+        visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
+        ty: wgpu::BindingType::Buffer {
+            ty: if storage {
+                wgpu::BufferBindingType::Storage { read_only: true }
+            } else {
+                wgpu::BufferBindingType::Uniform
+            },
+            has_dynamic_offset: false,
+            min_binding_size: None,
+        },
+        count: None,
+    };
+    let entries = [
+        vec![binding(0, false)],
+        if flat {
+            vec![binding(0, true), binding(1, true)]
+        } else {
+            vec![]
+        },
+        vec![],
+        if flat {
+            vec![binding(0, true), binding(1, true), binding(2, true)]
+        } else {
+            vec![]
+        },
+    ];
+    let layouts: Vec<_> = entries
+        .iter()
+        .map(|entries| {
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                label: None,
+                entries,
+            })
+        })
+        .collect();
+    let bindings = [
+        vec![(0, &uniform)],
+        if flat {
+            vec![(0, &slots), (1, &origins)]
+        } else {
+            vec![]
+        },
+        vec![],
+        if flat {
+            vec![(0, &ids), (1, &data), (2, &rects)]
+        } else {
+            vec![]
+        },
+    ];
+    let groups: Vec<_> = layouts
+        .iter()
+        .zip(bindings)
+        .map(|(layout, buffers)| {
+            device.create_bind_group(&wgpu::BindGroupDescriptor {
+                label: None,
+                layout,
+                entries: &buffers
+                    .into_iter()
+                    .map(|(binding, buffer)| wgpu::BindGroupEntry {
+                        binding,
+                        resource: buffer.as_entire_binding(),
+                    })
+                    .collect::<Vec<_>>(),
+            })
+        })
+        .collect();
+    let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+        label: None,
+        bind_group_layouts: &layouts.iter().map(Some).collect::<Vec<_>>(),
+        ..Default::default()
+    });
+    let module = |module| {
+        device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: None,
+            source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)),
+        })
+    };
+    let vs = module(program.vertex.clone());
+    let fs = module(program.fragment.clone());
+    let vertices = [
+        Some(wgpu::VertexBufferLayout {
+            array_stride: std::mem::size_of::<TerrainVertex>() as u64,
+            step_mode: wgpu::VertexStepMode::Vertex,
+            attributes: &crate::gfx::TERRAIN_ATTRIBUTES,
+        }),
+        Some(wgpu::VertexBufferLayout {
+            array_stride: 16,
+            step_mode: wgpu::VertexStepMode::Instance,
+            attributes: &wgpu::vertex_attr_array![5 => Float32x4],
+        }),
+    ];
+    let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: None,
+        layout: Some(&layout),
+        vertex: wgpu::VertexState {
+            module: &vs,
+            entry_point: Some("main"),
+            compilation_options: Default::default(),
+            buffers: &vertices[..if flat { 1 } else { 2 }],
+        },
+        primitive: wgpu::PrimitiveState {
+            topology: if geometry {
+                wgpu::PrimitiveTopology::TriangleList
+            } else {
+                wgpu::PrimitiveTopology::PointList
+            },
+            ..Default::default()
+        },
+        depth_stencil: None,
+        multisample: Default::default(),
+        fragment: Some(wgpu::FragmentState {
+            module: &fs,
+            entry_point: Some("main"),
+            compilation_options: Default::default(),
+            targets: &[Some(wgpu::ColorTargetState {
+                format: wgpu::TextureFormat::Rgba32Uint,
+                blend: None,
+                write_mask: wgpu::ColorWrites::ALL,
+            })],
+        }),
+        multiview_mask: None,
+        cache: None,
+    });
+    let output = device.create_texture(&wgpu::TextureDescriptor {
+        label: None,
+        size: wgpu::Extent3d {
+            width: 1,
+            height: 1,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Rgba32Uint,
+        usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+        view_formats: &[],
+    });
+    let read = device.create_buffer(&wgpu::BufferDescriptor {
+        label: None,
+        size: 16,
+        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+        mapped_at_creation: false,
+    });
+    let view = output.create_view(&Default::default());
+    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: &view,
+                depth_slice: None,
+                resolve_target: None,
+                ops: wgpu::Operations {
+                    load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
+                    store: wgpu::StoreOp::Store,
+                },
+            })],
+            ..Default::default()
+        });
+        pass.set_pipeline(&pipeline);
+        for (n, group) in groups.iter().enumerate() {
+            pass.set_bind_group(n as u32, group, &[]);
+        }
+        pass.set_vertex_buffer(0, data.slice(..));
+        if !flat {
+            pass.set_vertex_buffer(1, origins.slice(..));
+        }
+        pass.draw(0..if geometry { 3 } else { 1 }, 0..1);
+    }
+    encoder.copy_texture_to_buffer(
+        output.as_image_copy(),
+        wgpu::TexelCopyBufferInfo {
+            buffer: &read,
+            layout: Default::default(),
+        },
+        output.size(),
+    );
+    queue.submit([encoder.finish()]);
+    read.map_async(wgpu::MapMode::Read, .., |_| {});
+    device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+    *bytemuck::from_bytes(&read.get_mapped_range(..).unwrap())
+}
@@ -171,13 +171,98 @@ fn flat_draws_map_uvs_onto_a_stitched_sprite() {
    assert!(failures.is_empty(), "{}", failures.join("\n"));
 }

+/// Read back with a probe pack of ours, Iris 1.11.7's terrain `gl_Vertex` (camera on the block
+/// grid) puts a water top, 8/9 - 0.001 of a block up, at 29094/32768, and plants offset by 13/15
+/// and 0.1 of a block at 28398/32768 and 3276/32768 (#8464): each 32768th below the position.
+/// Whole blocks and sixteenths stay where they are.
+#[test]
+fn terrain_vertices_go_down_to_the_32768th_below_them() {
+    let instance = crate::gfx::test_gpu::instance();
+    let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
+        return;
+    };
+    let (device, queue) = pollster::block_on(adapter.request_device(&Default::default())).unwrap();
+    let texture = device.create_texture(&wgpu::TextureDescriptor {
+        label: None,
+        size: wgpu::Extent3d {
+            width: 16,
+            height: 16,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Rgba8Unorm,
+        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_SRC,
+        view_formats: &[],
+    });
+    let mut encoder = device.create_command_encoder(&Default::default());
+    let atlas = PackAtlas::new(&device, &mut encoder, &[texture], 1, 1, 16).unwrap();
+    queue.submit([encoder.finish()]);
+    let water = 8.0f32 / 9.0 - 0.001;
+    let cases = [
+        ([0.1, water, 13.0 / 15.0], [3276.0, 29094.0, 28398.0]),
+        ([13.0 / 15.0, 0.1, water], [28398.0, 3276.0, 29094.0]),
+        ([1.0, 0.5, 15.9375], [32768.0, 16384.0, 522240.0]),
+    ];
+    let vertices: Vec<_> = cases
+        .iter()
+        .map(|&(pos, _)| TerrainVertex::new(pos, [0.0, 0.0], 0x8000, u32::MAX, 0))
+        .collect();
+    let origin = f32::from_bits((1. / UV_STEPS).to_bits());
+    let mut failures = Vec::new();
+    for flat in [true, false] {
+        for shadow in [false, true] {
+            let read = sample_probe(
+                &device,
+                &queue,
+                &atlas,
+                &vertices,
+                origin,
+                [flat, shadow],
+                "gl_Vertex",
+            );
+            for ((pos, expected), got) in cases.iter().zip(&read) {
+                let got = [got[0], got[1], got[2]].map(|v| v * 32768.0);
+                if got != *expected {
+                    failures.push(format!(
+                        "{pos:?}, flat={flat} shadow={shadow}: {got:?} != {expected:?}"
+                    ));
+                }
+            }
+        }
+    }
+    assert!(failures.is_empty(), "{}", failures.join("\n"));
+}
+
 fn sample(
+    device: &wgpu::Device,
+    queue: &wgpu::Queue,
+    atlas: &PackAtlas,
+    vertices: &[TerrainVertex],
+    scale: f32,
+    flags: [bool; 2],
+) -> Vec<[f32; 4]> {
+    sample_probe(
+        device,
+        queue,
+        atlas,
+        vertices,
+        scale,
+        flags,
+        "vec4(mc_midTexCoord, gl_MultiTexCoord0.xy)",
+    )
+}
+
+/// What the pack's vertex stage sets `probe` to (`expression`), for each of `vertices`.
+fn sample_probe(
    device: &wgpu::Device,
    queue: &wgpu::Queue,
    atlas: &PackAtlas,
    vertices: &[TerrainVertex],
    scale: f32,
    [flat, shadow]: [bool; 2],
+    expression: &str,
 ) -> Vec<[f32; 4]> {
    let pp = |code| horizon_shaders::Preprocessed {
        code,
@@ -185,7 +270,7 @@ fn sample(
    };
    let vertex = pp(format!(
        "attribute vec2 mc_midTexCoord;\nvarying vec4 probe;\nvoid main() {{\n\
-         probe = vec4(mc_midTexCoord, gl_MultiTexCoord0.xy);\n\
+         probe = {expression};\n\
         gl_Position = vec4((float(gl_VertexID) + 0.5) * {} - 1.0, 0.0, 0.0, 1.0);\n}}",
        2. / vertices.len() as f32,
    ));
@@ -16,14 +16,16 @@ const MAPPED: u8 = 3;
 const ROW: u32 = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT;

 const SHADER: &str = "
-@group(0) @binding(0) 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(0) var depth: texture_2d<f32>;
@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
    let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
    return vec4<f32>(p * 2.0 - 1.0, 0.0, 1.0);
 }
@fragment fn fs() -> @location(0) vec4<f32> {
    let centre = vec2<i32>(textureDimensions(depth) / 2u);
-    return vec4<f32>(textureLoad(depth, centre, 0), 0.0, 0.0, 1.0);
+    return vec4<f32>(textureLoad(depth, centre, 0).r, 0.0, 0.0, 1.0);
 }
 ";

@@ -64,7 +66,7 @@ impl CenterDepth {
                binding: 0,
                visibility: wgpu::ShaderStages::FRAGMENT,
                ty: wgpu::BindingType::Texture {
-                    sample_type: wgpu::TextureSampleType::Depth,
+                    sample_type: wgpu::TextureSampleType::Float { filterable: false },
                    view_dimension: wgpu::TextureViewDimension::D2,
                    multisampled: false,
                },
@@ -102,6 +102,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
            reference: 0.1,
        }),
        item_id_declared: false,
+        far_depth: false,
    }
 }

@@ -164,6 +165,7 @@ pub fn cloud_inputs() -> horizon_shaders::GbuffersInputs {
        after: String::new(),
        alpha_test: None,
        item_id_declared: false,
+        far_depth: false,
    }
 }

@@ -51,6 +51,7 @@ pub fn inputs() -> horizon_shaders::GbuffersInputs {
        after,
        alpha_test: None,
        item_id_declared: false,
+        far_depth: false,
    }
 }

@@ -37,12 +37,24 @@ mod world_target_tests;
 #[cfg(test)]
 mod higher_shadowcolor_tests;

+#[cfg(test)]
+mod single_side_tests;
+
 #[cfg(test)]
 mod shadow_faces_tests;

 #[cfg(test)]
 mod forced_flip_tests;

+#[cfg(test)]
+mod weather_depth_tests;
+
+#[cfg(test)]
+mod custom_type_tests;
+
+#[cfg(test)]
+mod sky_depth_tests;
+
 /// The texture behind a pack sampler name.
 #[derive(Clone, Copy, PartialEq)]
 enum Source {
@@ -99,6 +111,8 @@ enum SamplerKind {
    Nearest,
    Repeat,
    NearestRepeat,
+    /// The block atlas: nearest texels, blended between the two nearest levels.
+    Atlas,
    Comparison,
 }

@@ -108,15 +122,15 @@ impl SamplerKind {
            Source::Color(_) | Source::ShadowColor(_) | Source::Dummy if !filtering => {
                Self::Nearest
            }
-            // shadowtex0/1 through a plain sampler: linear, as Iris 1.11.7 reads them, when the
-            // device filters their copies (`ShadowTargets::linear`).
-            Source::ShadowDepth(_, false) if filtering => Self::Linear,
            Source::Depth | Source::Depth1 | Source::Depth2 | Source::ShadowDepth(_, false) => {
                Self::Nearest
            }
            Source::Noise => Self::Repeat,
            Source::Shadow | Source::ShadowDepth(_, true) => Self::Comparison,
-            // Blocks look as the game draws them: nearest texels.
+            // Blocks look as the game draws them: nearest texels. Between levels, Iris 1.11.7
+            // blends `gtexture`'s two nearest (our probe packs, #9307: a read at level 1.25 is
+            // levels 1 and 2 mixed 3:1).
+            Source::Atlas if filtering => Self::Atlas,
            Source::Atlas | Source::Normals | Source::Specular => Self::NearestRepeat,
            Source::Image(_) if filtering => Self::Linear,
            Source::Image(_) => Self::Nearest,
@@ -134,7 +148,7 @@ impl SamplerKind {

    fn binding_type(self) -> wgpu::SamplerBindingType {
        match self {
-            Self::Linear | Self::Repeat => wgpu::SamplerBindingType::Filtering,
+            Self::Linear | Self::Repeat | Self::Atlas => wgpu::SamplerBindingType::Filtering,
            Self::Nearest | Self::NearestRepeat => wgpu::SamplerBindingType::NonFiltering,
            Self::Comparison => wgpu::SamplerBindingType::Comparison,
        }
@@ -357,6 +371,8 @@ struct Pass {
    writes: Vec<(u32, usize)>,
    /// Buffers flipped after the pass.
    flip: u16,
+    /// `hz_depth_linear`: which of the depth samplers a plain sampler reads filter.
+    depth_linear: [f32; 4],
    /// Buffers sampled, for the bind group cache key.
    reads: u16,
    /// shadowcolor buffers sampled by a program of the other buffers.
@@ -417,6 +433,14 @@ struct Mips {
    levels: Vec<(wgpu::TextureView, wgpu::BindGroup)>,
 }

+/// The picture a pack's `final` draws at the world's size while the window is another: it is
+/// copied onto the window once, after the pack's passes, as the game's own post pass does
+/// without a pack.
+struct FinalTarget {
+    size: [u32; 2],
+    view: wgpu::TextureView,
+}
+
 struct Targets {
    size: [u32; 2],
    /// A and B of each buffer used.
@@ -516,8 +540,14 @@ pub struct PackPost {
    passes: Vec<Pass>,
    /// Shadow cache for temporal reprojection.
    shadow_cache: ShadowCache,
-    /// What draws terrain (`gbuffers_terrain` or its fallback), between `prepare` and `deferred`.
+    /// What draws terrain (`gbuffers_terrain` or its fallback), between `prepare` and `deferred`;
+    /// when the pack draws terrain in two parts, solid terrain only (`gbuffers_terrain_solid` or
+    /// its fallback).
    terrain: Option<Pass>,
+    /// What draws cutout terrain (`gbuffers_terrain_cutout` or its fallback), after `terrain`,
+    /// when the pack draws terrain in two parts. A pack with no program for one part has only
+    /// the other.
+    terrain_cutout: Option<Pass>,
    /// What draws translucent terrain (`gbuffers_water` or its fallback), after `deferred`.
    water: Option<Pass>,
    /// What draws the sky (`gbuffers_skybasic` or its fallback), before terrain, and its vertices.
@@ -593,6 +623,8 @@ pub struct PackPost {
    rgb: u16,
    rgb_unset: bool,
    used: u16,
+    /// Buffers some pass draws into the "alt" side of or flips; the others' B is their A.
+    doubled: u16,
    /// `size.buffer.*`.
    sizes: [Option<horizon_shaders::BufferSize>; BUFFERS],
    /// Buffers bound as images, and those also copied for a pass that samples them.
@@ -627,6 +659,7 @@ pub struct PackPost {
    nearest: wgpu::Sampler,
    repeat: wgpu::Sampler,
    nearest_repeat: wgpu::Sampler,
+    atlas_sampler: wgpu::Sampler,
    /// None when it would write nothing: colortex0 holds integers and there is no depth to copy
    /// nor buffer to clear.
    blit: Option<(wgpu::RenderPipeline, wgpu::BindGroupLayout)>,
@@ -639,6 +672,12 @@ pub struct PackPost {
    blit_group: Option<([wgpu::TextureView; 2], wgpu::BindGroup)>,
    /// Shows colortex0 when the pack has no `final` (OQ-5).
    copy: (wgpu::RenderPipeline, wgpu::BindGroupLayout),
+    /// Copies the picture `final` drew at the world's size onto the window: no flip, it is
+    /// already in the screen's rows.
+    upscale: (wgpu::RenderPipeline, wgpu::BindGroupLayout),
+    /// The picture `final` draws while the world's size is not the window's.
+    final_target: Option<FinalTarget>,
+    screen: wgpu::TextureFormat,
    uniforms: FrameUniforms,
 }

@@ -678,6 +717,43 @@ fn texture_format(f: Format, features: wgpu::Features) -> wgpu::TextureFormat {
    }
 }

+/// `format` where `renders` says it can be a colour target, else the nearest float format that can:
+/// the same channels at 16 bits, then `Rgba8Unorm`. On OpenGL the 32-bit and 16-bit float formats
+/// render only with `GL_EXT_color_buffer_float`/`half_float`, and wgpu aborts on creating a target
+/// without. Other formats pass through. Float colour buffers are only sampled (never blended), so
+/// RENDER_ATTACHMENT is the only usage that decides.
+fn renderable_float(
+    format: wgpu::TextureFormat,
+    renders: impl Fn(wgpu::TextureFormat) -> bool,
+) -> wgpu::TextureFormat {
+    use wgpu::TextureFormat as T;
+    let half = match format {
+        T::R32Float | T::R16Float => T::R16Float,
+        T::Rg32Float | T::Rg16Float => T::Rg16Float,
+        T::Rgba32Float | T::Rgba16Float => T::Rgba16Float,
+        _ => return format,
+    };
+    if renders(format) {
+        format
+    } else if renders(half) {
+        half
+    } else {
+        T::Rgba8Unorm
+    }
+}
+
+/// [`texture_format`] made renderable on this adapter (see [`renderable_float`]).
+fn target_format(
+    f: Format,
+    features: wgpu::Features,
+    adapter: &wgpu::Adapter,
+) -> wgpu::TextureFormat {
+    renderable_float(texture_format(f, features), |format| {
+        (adapter.get_texture_format_features(format).allowed_usages)
+            .contains(wgpu::TextureUsages::RENDER_ATTACHMENT)
+    })
+}
+
 /// The SNORM wgpu format of SNORM pack format `f`, where this adapter can render to it. Iris
 /// stores such a buffer clamped to [-1, 1] and quantised to its bits; elsewhere the half floats of
 /// [`texture_format`] stand in.
@@ -720,6 +796,14 @@ fn fits(ty: &str, sample_type: wgpu::TextureSampleType) -> bool {
        }
 }

+/// `hz_depth_linear` for a program: 1 for each of shadowtex0, shadowtex1, `shadow` and
+/// `watershadow` whose depth filters (`linear`, bit n: shadowtex n). `shadow` is shadowtex1 in a
+/// program that also declares `watershadow` (6.3).
+fn depth_linear(interface: &horizon_shaders::Interface, linear: u8) -> [f32; 4] {
+    let watershadow = interface.samplers.iter().any(|s| s.name == "watershadow");
+    [0, 1, usize::from(watershadow), 0].map(|n| f32::from(linear >> n & 1))
+}
+
 fn source(name: &str, shadow_space: bool, shadow_pass: bool, watershadow: bool) -> Source {
    let shadow_color = horizon_shaders::shadow_color(name);
    let shadow_depth = match name {
@@ -1042,6 +1126,11 @@ pub(super) struct ShadowView {
    /// shadow map holds the faces turned away from the light too (#9033): under a hill at low sun
    /// a cave's ceiling, which faces away, is often all that shadows the cave.
    pub every_face: bool,
+    /// Only the sections whose shadow can fall into the camera's view: those the camera's
+    /// frustum, stretched toward the light, takes in (`shadow_casters`). Our probes' Iris 1.11.7
+    /// maps fit keeping only those with `shadow.culling` unset (#8464): under a noon sun, only
+    /// the terrain above the ground the camera sees; with a low sun ahead, none behind the camera.
+    pub view_casters: bool,
 }

 /// Set 3 of flat terrain, read by the vertex stage: the sprite layers' table (`mc_Entity`'s id
@@ -1128,7 +1217,7 @@ struct Resources<'a> {
    /// The formats and dimensions of the images no `image.*` gives, for their stand-ins.
    stand_ins: &'a std::cell::RefCell<Vec<(wgpu::TextureFormat, wgpu::TextureViewDimension)>>,
    /// Bit n: shadowtex n read through a plain sampler filters linearly (`shadowtexNNearest`
-    /// unset, and the device filters `R32Float`).
+    /// unset): the translator's helpers blend a gather of it (`hz_depth_linear`).
    shadow_linear: u8,
 }

@@ -1246,6 +1335,36 @@ fn bindings(
            }
            None => {
                let mut src = source(&s.name, group.shadow(), shadow.is_some(), watershadow);
+                // A sampler the game gives no texture reads texture unit 0, as do the atlas's
+                // names: the atlas in gbuffers programs, `colortex0` in deferred, composite and
+                // final (OptiFine's shaders.txt). Iris 1.11.7 read the atlas through a name of
+                // ours in gbuffers_terrain, and the scene in `colortex0` through such a name and
+                // through `gtexture`, `tex` and `texture` in those three, with or without
+                // `colortex0` declared (probe packs of ours, #9307). Translucent programs and
+                // the other groups weren't measured and keep the stand-in.
+                let unit_0 = match group {
+                    Group::Gbuffers => Some(Source::Atlas),
+                    Group::Deferred | Group::Composite | Group::Final => Some(Source::Color(0)),
+                    _ => None,
+                };
+                // A name of the game's that has no texture here (a shadow sampler with no
+                // shadow pass) stays blank; so does a sampler that isn't 2D, and one under a
+                // `texture.<stage>.<name>` left unbound (#9064's probe read a 16-texel-wide
+                // texture there in final, undiagnosed).
+                let unknown = src == Source::Dummy
+                    && source(&s.name, false, true, false) == Source::Dummy
+                    && s.ty == "sampler2D"
+                    && !textures.iter().any(|t| t.name == s.name);
+                // colortex0 to colortex3 (gcolor, gdepth, gnormal, composite) are no gbuffers
+                // samplers in shaders.txt's table: Iris 1.11.7 read the atlas through each of
+                // colortex0-3 and gnormal in gbuffers_terrain (our probe, #9307).
+                let not_gbuffers =
+                    group == Group::Gbuffers && matches!(src, Source::Color(n) if n < 4);
+                if let Some(unit_0) = unit_0
+                    && (src == Source::Atlas || unknown || not_gbuffers)
+                {
+                    src = unit_0;
+                }
                let blank = match src {
                    // The shadow pass writes the shadow map.
                    Source::ShadowDepth(..) => group == Group::Shadow,
@@ -1263,7 +1382,6 @@ fn bindings(
                    Source::ShadowColor(n) => shadow
                        .and_then(|f| f[n].sample_type(None, Some(features)))
                        .unwrap_or(float),
-                    Source::ShadowDepth(n, false) if pack.shadow_linear & 1 << n != 0 => float,
                    Source::Depth | Source::Depth1 | Source::Depth2 | Source::ShadowDepth(..) => {
                        wgpu::TextureSampleType::Float { filterable: false }
                    }
@@ -1466,6 +1584,22 @@ fn image_format(qualifier: &str) -> Option<wgpu::TextureFormat> {
    })
 }

+/// The value slot of the pack's custom uniform `name` for a program declaring it as GLSL type
+/// `ty`: after the frame's uniforms, in the order of `custom` (each with the type
+/// `shaders.properties` gives it). A `float`, `int`, `vec2`, `vec3` or `vec4` custom uniform
+/// declared as another of these types gets none, and reads 0: Iris 1.11.7 logs "Wrong uniform
+/// type ... Disabling that uniform" and our probes read 0 there (float as int, int as float,
+/// vec3 as vec2, vec2 as vec3; the vec4 cases were not probed). Other pairs (a `bool` on either
+/// side) keep the conversion `Value::write` makes: our probe read a float of 2.5 declared
+/// `bool` as true in both games.
+fn custom_index(custom: &[(String, String)], name: &str, ty: &str) -> Option<usize> {
+    const STRICT: [&str; 5] = ["float", "int", "vec2", "vec3", "vec4"];
+    let k = custom.iter().position(|(c, _)| c == name)?;
+    let declared = custom[k].1.as_str();
+    let disabled = declared != ty && STRICT.contains(&declared) && STRICT.contains(&ty);
+    (!disabled).then_some(pack_uniforms::NAMES.len() + k)
+}
+
 /// The pass of program `p`: a quad, or `geometry` drawn by the game. `None` (with a note) when
 /// wgpu refuses it or it writes nothing. `formats` are its buffers' (for a program of the shadow
 /// buffers, buffer n is shadowcolor n); `shadow` the shadowcolor formats when the shadow pass
@@ -1479,17 +1613,14 @@ fn build_pass(
    screen: wgpu::TextureFormat,
    notes: &mut Vec<String>,
    geometry: Option<&Geometry<'_>>,
-    custom: &[String],
+    custom: &[(String, String)],
    draws: &wgpu::BindGroupLayout,
    pack: &Resources<'_>,
 ) -> Option<Pass> {
    let features = device.features();
    // The frame's uniforms, then the pack's custom ones.
-    let index = |name: &str| {
-        pack_uniforms::index_in(name, geometry.is_some()).or_else(|| {
-            let k = custom.iter().position(|c| c == name)?;
-            Some(pack_uniforms::NAMES.len() + k)
-        })
+    let index = |name: &str, ty: &str| {
+        pack_uniforms::index_in(name, geometry.is_some()).or_else(|| custom_index(custom, name, ty))
    };
    let mask = |flips: &[(u32, bool)]| flips.iter().filter(|f| f.1).fold(0u16, |m, f| m | 1 << f.0);
    let mut p = p;
@@ -1681,7 +1812,7 @@ fn build_pass(
    let missing: Vec<&str> = interface
        .uniforms
        .iter()
-        .filter(|u| !u.name.starts_with("hz_") && index(&u.name).is_none())
+        .filter(|u| !u.name.starts_with("hz_") && index(&u.name, &u.ty).is_none())
        .map(|u| u.name.as_str())
        .collect();
    if !missing.is_empty() {
@@ -1703,7 +1834,7 @@ fn build_pass(
        uniforms: interface
            .uniforms
            .iter()
-            .map(|u| (index(&u.name), u.ty.clone(), u.offset))
+            .map(|u| (index(&u.name, &u.ty), u.ty.clone(), u.offset))
            .collect(),
        name: p.name,
        group: p.group,
@@ -1712,6 +1843,7 @@ fn build_pass(
        samplers,
        writes,
        flip,
+        depth_linear: depth_linear(interface, pack.shadow_linear),
        shadow_reads,
        written,
        mipmaps: p.mipmaps,
@@ -1756,14 +1888,11 @@ fn build_compute(
    formats: &[wgpu::TextureFormat; BUFFERS],
    shadow: Option<&[wgpu::TextureFormat; SHADOW_COLORS]>,
    notes: &mut Vec<String>,
-    custom: &[String],
+    custom: &[(String, String)],
    pack: &Resources<'_>,
 ) -> Option<Pass> {
-    let index = |name: &str| {
-        pack_uniforms::index(name).or_else(|| {
-            let k = custom.iter().position(|c| c == name)?;
-            Some(pack_uniforms::NAMES.len() + k)
-        })
+    let index = |name: &str, ty: &str| {
+        pack_uniforms::index(name).or_else(|| custom_index(custom, name, ty))
    };
    let interface = &c.interface;
    let (entries, samplers, slots, reads, shadow_reads, images) = bindings(
@@ -1832,7 +1961,7 @@ fn build_compute(
        uniforms: interface
            .uniforms
            .iter()
-            .map(|u| (index(&u.name), u.ty.clone(), u.offset))
+            .map(|u| (index(&u.name, &u.ty), u.ty.clone(), u.offset))
            .collect(),
        name,
        group,
@@ -1846,6 +1975,7 @@ fn build_compute(
        samplers,
        writes: Vec::new(),
        flip: 0,
+        depth_linear: depth_linear(interface, pack.shadow_linear),
        copies: written & reads | before_colors,
        reads: reads | written,
        shadow_reads,
@@ -1891,7 +2021,8 @@ impl PackPost {
        let features = device.features();
        let formats: [wgpu::TextureFormat; BUFFERS] = std::array::from_fn(|i| {
            let f = post.config.buffers[i].format;
-            snorm_format(f, features, adapter).unwrap_or_else(|| texture_format(f, features))
+            snorm_format(f, features, adapter)
+                .unwrap_or_else(|| target_format(f, features, adapter))
        });
        let sky_clear = Some(&post.config.buffers[0])
            .filter(|b| b.clear)
@@ -1927,7 +2058,9 @@ impl PackPost {
        // shadowcolor2 to 7 only for a pack that names `HIGHER_SHADOWCOLOR`.
        let shadow_colors = (1u16 << post.shadow_colors) - 1;
        let mut custom = post.custom;
-        let custom_names: Vec<String> = custom.uniforms().map(|u| u.0.to_owned()).collect();
+        let custom_names: Vec<(String, String)> = (custom.uniforms())
+            .map(|(name, ty)| (name.to_owned(), ty.to_owned()))
+            .collect();
        // A first run finds the names neither the frame nor the pack defines.
        custom.eval(0.0, &pack_uniforms::zero);
        // Its zeros are no start for `smooth`: the first frame's values are, as in Iris.
@@ -1939,12 +2072,17 @@ impl PackPost {
        let mask =
            |flips: &[(u32, bool)]| flips.iter().filter(|f| f.1).fold(0u16, |m, f| m | 1 << f.0);
        let mut used = 1u16;
+        // Buffers some pass draws into the "alt" side of, or flips: only these get a B texture.
+        let mut doubled = mask(&post.deferred_pre) | mask(&post.composite_pre);
+        let mut shadow_doubled = 0u16;
        let draws = DrawUniforms::new(device);
        // The shadow buffers' formats when the shadow pass runs; their programs see them as
        // buffers 0 to 7.
        let shadow_formats: Option<[wgpu::TextureFormat; SHADOW_COLORS]> =
            post.shadow_pass.then(|| {
-                std::array::from_fn(|n| texture_format(shadow_config.colors[n].format, features))
+                std::array::from_fn(|n| {
+                    target_format(shadow_config.colors[n].format, features, adapter)
+                })
            });
        let shadow_space: [wgpu::TextureFormat; BUFFERS] = std::array::from_fn(|i| {
            shadow_formats
@@ -2020,13 +2158,9 @@ impl PackPost {
            packed,
            released: std::cell::Cell::new(("", 0)),
            stand_ins: &stand_ins,
-            shadow_linear: if features.contains(wgpu::Features::FLOAT32_FILTERABLE) {
-                (0..2)
-                    .filter(|&n| !shadow_config.nearest[n])
-                    .fold(0, |m, n| m | 1 << n)
-            } else {
-                0
-            },
+            shadow_linear: (0..2)
+                .filter(|&n| !shadow_config.nearest[n])
+                .fold(0, |m, n| m | 1 << n),
        };
        let mut build = |mut p: horizon_shaders::PostProgram, geometry: Option<&Geometry<'_>>| {
            let in_shadow = p.group.shadow();
@@ -2095,11 +2229,29 @@ impl PackPost {
                ));
                return None;
            }
+            // Composite-style programs draw into the "alt" side of what they write; gbuffers,
+            // shadow and `final` programs write in place, compute programs through images.
+            let alt = if geometry.is_none()
+                && group != Group::Final
+                && matches!(pass.pipeline, Pipeline::Render(_))
+            {
+                pass.written
+            } else {
+                0
+            };
+            if in_shadow {
+                shadow_doubled |= alt;
+            } else {
+                doubled |= alt;
+            }
            for p in std::iter::once(&pass).chain(&pass.compute) {
                let (stage, flipped) = pack.released.get();
                pack.released.set((stage, flipped | p.flip));
-                if !in_shadow {
+                if in_shadow {
+                    shadow_doubled |= p.flip;
+                } else {
                    used |= p.reads | p.written | p.flip;
+                    doubled |= p.flip;
                }
                storage |= image_buffers(&p.images);
                image_copied |= p.image_copies;
@@ -2123,10 +2275,15 @@ impl PackPost {
            ids: block_ids.as_ref().map(|i| &i.0),
            cull: g.cull,
        });
-        let terrain = post
+        let split = post.terrain.is_some() && post.terrain_cutout.is_some();
+        let mut terrain = post
            .terrain
            .zip(terrain_geometry.as_ref())
            .and_then(|(p, g)| build(p, Some(g)));
+        let mut terrain_cutout = post
+            .terrain_cutout
+            .zip(terrain_geometry.as_ref())
+            .and_then(|(p, g)| build(p, Some(g)));
        let water = post
            .water
            .zip(terrain_geometry.as_ref())
@@ -2255,7 +2412,7 @@ impl PackPost {
        let weather_geometry = world.weather.then(|| Geometry {
            buffers: &entity_buffers,
            table: None,
-            depth_write: true,
+            depth_write: post.rain_depth,
            atlas: None,
            material_maps: false,
            ids: None,
@@ -2331,8 +2488,31 @@ impl PackPost {
            .filter_map(|p| build(p, None))
            .collect();
        let stand_ins = pack_images::stand_ins(device, stand_ins.take());
-        if let Some(t) = &terrain {
-            notes.push(format!("terrain draws with {}", t.name));
+        // Terrain in two parts draws both or neither: one alone would leave the other part's
+        // terrain undrawn. Without either, the game draws all terrain, as when the terrain
+        // program of a pack that doesn't split can't draw.
+        if split
+            && terrain.is_some() != terrain_cutout.is_some()
+            && let Some(p) = terrain.take().or(terrain_cutout.take())
+        {
+            notes.push(format!(
+                "{}: the other part of terrain can't draw; the game draws all terrain",
+                p.name
+            ));
+        }
+        match (&terrain, &mut terrain_cutout) {
+            (Some(t), None) => notes.push(format!("terrain draws with {}", t.name)),
+            (t, Some(c)) => {
+                if let Some(t) = t {
+                    notes.push(format!("solid terrain draws with {}", t.name));
+                }
+                notes.push(format!("cutout terrain draws with {}", c.name));
+                // Timed (and labelled) apart from the solid part when it runs the same program.
+                if t.as_ref().is_some_and(|t| t.name == c.name) {
+                    c.name.push_str(" (cutout)");
+                }
+            }
+            (None, None) => {}
        }
        for (part, pass) in [
            ("terrain", &shadow_terrain),
@@ -2416,6 +2596,7 @@ impl PackPost {
                .iter()
                .chain(&shadow_comp)
                .chain(&terrain)
+                .chain(&terrain_cutout)
                .chain(&water))
            .chain(shadow_terrain.iter().chain(&shadow_water))
            .chain(sky.iter().flat_map(|s| s.basic.iter().chain(&s.textured)))
@@ -2438,30 +2619,28 @@ impl PackPost {
            let depth1 = every_pass()
                .flat_map(|p| &p.samplers)
                .any(|s| matches!(s.source, Source::ShadowDepth(1, _)));
-            let linear = every_pass()
-                .flat_map(|p| &p.samplers)
-                .filter(|s| s.filtering)
-                .fold(0u8, |m, s| match s.source {
-                    Source::ShadowDepth(n, false) => m | 1 << n,
-                    _ => m,
-                });
            let t = super::pack_shadow::ShadowTargets::new(
                device,
                &shadow_config,
                f,
                colors,
+                shadow_doubled & colors,
                depth1,
-                linear,
            );
            notes.push(format!(
-                "shadow map {0}x{0} over {2} blocks, sunPathRotation {3}, shadowcolor buffers {colors:#b}{1}",
+                "shadow map {0}x{0} over {2} blocks, sunPathRotation {3}, shadowcolor buffers {colors:#b} (two textures: {4:#b}){1}",
                t.size,
                if depth1 { ", shadowtex1" } else { "" },
                shadow_config.distance,
                shadow_config.sun_path_rotation,
+                shadow_doubled & colors,
            ));
            t
        });
+        log::info!(
+            "shader pack: colortex buffers {used:#b}, with two textures {:#b}",
+            doubled & used
+        );
        // Any program can leave pixels untouched. Composite-style passes also write the
        // alternate image, so their first write does not replace the main image's clear.
        let mut cleared = Vec::new();
@@ -2473,6 +2652,7 @@ impl PackPost {
                .iter()
                .flat_map(|s| s.basic.iter().chain(&s.textured))
                .chain(&terrain)
+                .chain(&terrain_cutout)
                .chain(entities.iter().flat_map(|e| e.passes.iter().flatten()))
                .chain(&clouds)
                .chain(&lines)
@@ -2488,6 +2668,7 @@ impl PackPost {
        }
        // Terrain tests against the world's depth (entities...), so the blit copies it then.
        let blit_depth = terrain.is_some()
+            || terrain_cutout.is_some()
            || water.is_some()
            || sky.is_some()
            || entities.as_ref().is_some_and(Entities::drawn)
@@ -2557,7 +2738,7 @@ impl PackPost {
                },
                &[
                    texture_entry(0, float),
-                    texture_entry(1, wgpu::TextureSampleType::Depth),
+                    texture_entry(1, wgpu::TextureSampleType::Float { filterable: false }),
                ],
                &blit_targets,
                // GL's window depth, written for depthtex0 and the terrain's depth test.
@@ -2584,6 +2765,20 @@ impl PackPost {
            &[target(screen)],
            None,
        );
+        let upscale = helper(
+            device,
+            "vs_screen",
+            "fs_copy",
+            &[
+                texture_entry(0, float),
+                entry(
+                    2,
+                    wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+                ),
+            ],
+            &[target(screen)],
+            None,
+        );
        let filterable = |b: usize| {
            formats[b].sample_type(None, Some(device.features()))
                == Some(wgpu::TextureSampleType::Float { filterable: true })
@@ -2625,6 +2820,7 @@ impl PackPost {
            setup_pending: true,
            passes,
            terrain,
+            terrain_cutout,
            water,
            sky,
            entities,
@@ -2668,6 +2864,7 @@ impl PackPost {
            rgb,
            rgb_unset: true,
            used,
+            doubled: doubled & used,
            storage,
            copied,
            sizes,
@@ -2774,8 +2971,18 @@ impl PackPost {
            ),
            repeat: sampler(device, wgpu::FilterMode::Linear, wgpu::AddressMode::Repeat),
            nearest_repeat: sampler(device, wgpu::FilterMode::Nearest, wgpu::AddressMode::Repeat),
+            atlas_sampler: device.create_sampler(&wgpu::SamplerDescriptor {
+                label: Some("Shader pack atlas"),
+                address_mode_u: wgpu::AddressMode::Repeat,
+                address_mode_v: wgpu::AddressMode::Repeat,
+                mipmap_filter: wgpu::MipmapFilterMode::Linear,
+                ..Default::default()
+            }),
            blit,
            copy,
+            upscale,
+            final_target: None,
+            screen,
            uniforms: {
                let mut u = FrameUniforms::default();
                u.atlas = world.atlas.map_or([0; 2], |a| a.1);
@@ -2818,7 +3025,8 @@ impl PackPost {
            }
        }
        let fog = self.uniforms.fog();
-        // Our block members first (`hz_target`, `hz_fog_color`, `hz_fog`), then the pack's.
+        // Our block members first (`hz_target`, `hz_fog_color`, `hz_fog`, `hz_depth_linear`),
+        // then the pack's.
        let ours = [
            [
                out[0] as f32,
@@ -2828,12 +3036,21 @@ impl PackPost {
            ],
            fog[0].to_array(),
            fog[1].to_array(),
+            pass.depth_linear,
        ];
        let head: &[u8] = bytemuck::cast_slice(&ours);
        let n = head.len().min(pass.block.len());
        pass.block[..n].copy_from_slice(&head[..n]);
        for (index, ty, offset) in &pass.uniforms {
-            if let Some(v) = index.and_then(|i| self.uniforms.values.get(i)) {
+            let Some((i, v)) = index.and_then(|i| Some((i, self.uniforms.values.get(i)?))) else {
+                continue;
+            };
+            // A built-in of another type keeps its initial value (0); custom uniforms were
+            // checked when the pass was built.
+            if pack_uniforms::NAMES
+                .get(i)
+                .is_none_or(|name| v.read_as(name, ty))
+            {
                v.write(ty, &mut pass.block, *offset as usize);
            }
        }
@@ -2871,12 +3088,6 @@ impl PackPost {
                        shadow_color(i, usize::from(key & 1 << (32 + i) != 0))
                            .unwrap_or(&self.dummy)
                    }
-                    Source::ShadowDepth(i, false) if s.filtering => {
-                        match shadow.and_then(|t| t.linear[i].as_ref()) {
-                            Some(v) => v,
-                            None => &self.dummy,
-                        }
-                    }
                    Source::ShadowDepth(i, _) => match shadow {
                        Some(t) => match (i, &t.depth1) {
                            (1, Some(d)) => &d.1,
@@ -2977,6 +3188,7 @@ impl PackPost {
                    SamplerKind::Nearest => &self.nearest,
                    SamplerKind::Repeat => &self.repeat,
                    SamplerKind::NearestRepeat => &self.nearest_repeat,
+                    SamplerKind::Atlas => &self.atlas_sampler,
                    SamplerKind::Comparison => shadow.map_or(&self.shadow.1, |t| &t.comparison),
                };
                entries.push(wgpu::BindGroupEntry {
@@ -3113,7 +3325,8 @@ impl PackPost {
    }

    /// Terrain (or, `translucent`, translucent terrain) with the pack's program; `draw` issues
-    /// the game's draws.
+    /// the game's draws. Solid terrain in two parts has its cutout part drawn second, from the
+    /// same draws.
    fn draw_terrain(
        &mut self,
        device: &wgpu::Device,
@@ -3123,13 +3336,35 @@ impl PackPost {
        list: TerrainList,
        draw: &mut TerrainDraw<'_>,
    ) {
-        let slot = match list {
+        self.draw_terrain_part(device, queue, encoder, size, list, false, draw);
+        if list == TerrainList::Solid {
+            self.draw_terrain_part(device, queue, encoder, size, list, true, draw);
+        }
+    }
+
+    /// The pass that draws `list`, or the cutout part of the solid list.
+    fn terrain_slot(&mut self, list: TerrainList, cutout: bool) -> &mut Option<Pass> {
+        match list {
+            TerrainList::Solid if cutout => &mut self.terrain_cutout,
            TerrainList::Solid => &mut self.terrain,
            TerrainList::Translucent => &mut self.water,
            TerrainList::ShadowSolid => &mut self.shadow_terrain,
            TerrainList::ShadowTranslucent => &mut self.shadow_water,
-        };
-        let Some(mut pass) = slot.take() else {
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn draw_terrain_part(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        encoder: &mut wgpu::CommandEncoder,
+        size: [u32; 2],
+        list: TerrainList,
+        cutout: bool,
+        draw: &mut TerrainDraw<'_>,
+    ) {
+        let Some(mut pass) = self.terrain_slot(list, cutout).take() else {
            return;
        };
        let translucent = list.translucent();
@@ -3167,12 +3402,7 @@ impl PackPost {
        if !pass.group.shadow() {
            self.mips_valid &= !pass.written;
        }
-        *match list {
-            TerrainList::Solid => &mut self.terrain,
-            TerrainList::Translucent => &mut self.water,
-            TerrainList::ShadowSolid => &mut self.shadow_terrain,
-            TerrainList::ShadowTranslucent => &mut self.shadow_water,
-        } = Some(pass);
+        *self.terrain_slot(list, cutout) = Some(pass);
    }

    /// The sky's parts in vanilla's order, each with the program that draws it; one render pass
@@ -3806,12 +4036,13 @@ impl PackPost {
                horizon_shaders::ShadowCulling::Reversed => Some(shadow.voxel_distance),
            },
            every_face: true,
+            view_casters: true,
        })
    }

    /// Whether the pack draws terrain itself.
    pub fn has_terrain(&self) -> bool {
-        self.terrain.is_some()
+        self.terrain.is_some() || self.terrain_cutout.is_some()
    }

    /// Whether the pack's shadow pass draws terrain (`shadow_view`).
@@ -3862,6 +4093,7 @@ impl PackPost {
            .passes
            .iter_mut()
            .chain(&mut self.terrain)
+            .chain(&mut self.terrain_cutout)
            .chain(&mut self.water)
            .chain(sky)
            .chain(entities)
@@ -3943,8 +4175,16 @@ impl PackPost {
                if i != 0 && self.clears[i].is_none() {
                    attachment |= wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::COPY_DST;
                }
-                let sides = [0, 1]
-                    .map(|_| texture_sized(&label, self.formats[i], attachment, levels, sizes[i]));
+                let side = || texture_sized(&label, self.formats[i], attachment, levels, sizes[i]);
+                let a = side();
+                let sides = [
+                    a.clone(),
+                    if self.doubled & 1 << i != 0 {
+                        side()
+                    } else {
+                        a
+                    },
+                ];
                if mipped && let Some((_, layout)) = self.down.get(&self.formats[i]) {
                    mips[i] = Some(sides.each_ref().map(|t| {
                        Mips {
@@ -4107,9 +4347,6 @@ impl PackPost {
            TerrainList::ShadowTranslucent,
            terrain,
        );
-        if let Some(t) = &self.shadow_targets {
-            t.copy_linear(encoder);
-        }
        let mut comp = std::mem::take(&mut self.shadow_comp);
        for pass in &mut comp {
            let mut compute = std::mem::take(&mut pass.compute);
@@ -4189,8 +4426,8 @@ impl PackPost {
        shadow.interval.to_bits().hash(&mut hasher);
        shadow.sun_path_rotation.to_bits().hash(&mut hasher);
        shadow.fov.map(|f| f.to_bits()).hash(&mut hasher);
-        shadow.near.to_bits().hash(&mut hasher);
-        shadow.far.to_bits().hash(&mut hasher);
+        shadow.near.map(f32::to_bits).hash(&mut hasher);
+        shadow.far.map(f32::to_bits).hash(&mut hasher);
        for hf in &shadow.hardware_filtering {
            hf.hash(&mut hasher);
        }
@@ -4278,6 +4515,35 @@ impl PackPost {
        terrain: &mut TerrainDraw<'_>,
    ) {
        self.resize(device, size);
+        // A resolution scale leaves the picture smaller (or larger) than the window: the pack's
+        // `final` draws it at the picture's size, and one copy takes it to the window (#9291).
+        let final_view = if size != window && self.passes.iter().any(|p| p.group == Group::Final) {
+            if self.final_target.as_ref().is_none_or(|t| t.size != size) {
+                let texture = device.create_texture(&wgpu::TextureDescriptor {
+                    label: Some("Shader pack final"),
+                    size: wgpu::Extent3d {
+                        width: size[0],
+                        height: size[1],
+                        depth_or_array_layers: 1,
+                    },
+                    mip_level_count: 1,
+                    sample_count: 1,
+                    dimension: wgpu::TextureDimension::D2,
+                    format: self.screen,
+                    usage: wgpu::TextureUsages::RENDER_ATTACHMENT
+                        | wgpu::TextureUsages::TEXTURE_BINDING,
+                    view_formats: &[],
+                });
+                self.final_target = Some(FinalTarget {
+                    size,
+                    view: texture.create_view(&Default::default()),
+                });
+            }
+            self.final_target.as_ref().map(|t| t.view.clone())
+        } else {
+            self.final_target = None;
+            None
+        };
        if let Some((layout, ids, rects)) = &self.block_ids {
            // A page that grew has a new buffer.
            self.page_groups
@@ -4380,7 +4646,10 @@ impl PackPost {
                store: wgpu::StoreOp::Store,
            };
            for b in (0..BUFFERS).filter(|&b| self.rgb & 1 << b != 0) {
-                for alt in [false, true] {
+                for alt in [false, true]
+                    .into_iter()
+                    .take(1 + usize::from(self.doubled & 1 << b != 0))
+                {
                    if let Some(v) = view(self.main, b, alt) {
                        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                            label: Some("Shader pack three-channel start"),
@@ -4413,7 +4682,8 @@ impl PackPost {
        let max_attachments = (limits.max_color_attachments as usize).min(8);
        // The buffers the blit doesn't clear, and the other texture of every cleared buffer.
        let alt_clears = (0..BUFFERS)
-            .filter(|&b| self.clears[b].is_some() && view(self.main, b, true).is_some())
+            .filter(|&b| self.clears[b].is_some() && self.doubled & 1 << b != 0)
+            .filter(|&b| view(self.main, b, true).is_some())
            .map(|b| (b, true));
        let mut by_size: Vec<([u32; 2], Vec<(usize, bool)>)> = Vec::new();
        for (b, alt) in self
@@ -4521,6 +4791,7 @@ impl PackPost {
        let mut shown = false;
        // A water-only pack still needs the opaque phase to populate requested snapshots.
        let mut terrain_drawn = self.terrain.is_none()
+            && self.terrain_cutout.is_none()
            && self.sky.is_none()
            && !self.entities.as_ref().is_some_and(Entities::drawn)
            && self.clouds.is_none()
@@ -4577,8 +4848,8 @@ impl PackPost {
            self.mips_valid |= stale;
            let final_pass = pass.group == Group::Final;
            // A pass writing buffers of a size of their own draws at that size (they share it).
+            // `final` draws the picture at the world's size; a copy takes it to the window.
            let out = match pass.writes.first() {
-                _ if final_pass => window,
                Some(&(_, b)) => self.targets.as_ref().map_or(size, |t| t.sizes[b]),
                None => size,
            };
@@ -4601,7 +4872,7 @@ impl PackPost {
                overwrite
            };
            if final_pass {
-                attachments.push(attach(screen, overwrite));
+                attachments.push(attach(final_view.as_ref().unwrap_or(screen), overwrite));
                shown = true;
            } else if pass.sink {
                attachments.push(attach(&targets.sink, ops));
@@ -4684,6 +4955,31 @@ impl PackPost {
            rp.set_pipeline(&self.copy.0);
            rp.set_bind_group(0, &group, &[]);
            rp.draw(0..3, 0..1);
+        } else if let Some(picture) = &final_view {
+            // The picture at the world's size onto the window: one upscale, smoothly.
+            let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+                label: Some("Shader pack final"),
+                layout: &self.upscale.1,
+                entries: &[
+                    wgpu::BindGroupEntry {
+                        binding: 0,
+                        resource: wgpu::BindingResource::TextureView(picture),
+                    },
+                    wgpu::BindGroupEntry {
+                        binding: 2,
+                        resource: wgpu::BindingResource::Sampler(&self.linear),
+                    },
+                ],
+            });
+            let mut rp = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("Shader pack final"),
+                color_attachments: &[attach(screen, overwrite)],
+                timestamp_writes: self.timing.as_mut().and_then(|t| t.writes("final copy")),
+                ..Default::default()
+            });
+            rp.set_pipeline(&self.upscale.0);
+            rp.set_bind_group(0, &group, &[]);
+            rp.draw(0..3, 0..1);
        }
    }
 }
@@ -4695,6 +4991,10 @@ mod snorm_tests;
 #[path = "pack_post/depth_test.rs"]
 mod depth_test;

+#[cfg(test)]
+#[path = "pack_post/terrain_parts_tests.rs"]
+mod terrain_parts_tests;
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -5284,6 +5584,27 @@ mod tests {
        assert_eq!(g("R11F_G11F_B10F"), T::Rg11b10Ufloat);
    }

+    #[test]
+    fn float_targets_fall_back_when_not_renderable() {
+        let all = |_| true;
+        assert_eq!(renderable_float(T::Rgba32Float, all), T::Rgba32Float);
+        // OpenGL without GL_EXT_color_buffer_float: only half floats render.
+        let half_only = |f: T| matches!(f, T::R16Float | T::Rg16Float | T::Rgba16Float);
+        assert_eq!(renderable_float(T::Rgba32Float, half_only), T::Rgba16Float);
+        assert_eq!(renderable_float(T::Rg32Float, half_only), T::Rg16Float);
+        assert_eq!(renderable_float(T::R32Float, half_only), T::R16Float);
+        assert_eq!(renderable_float(T::Rgba16Float, half_only), T::Rgba16Float);
+        // Neither renders: the 8-bit last resort.
+        assert_eq!(renderable_float(T::Rgba32Float, |_| false), T::Rgba8Unorm);
+        assert_eq!(renderable_float(T::Rg16Float, |_| false), T::Rgba8Unorm);
+        // Other formats are never replaced.
+        assert_eq!(renderable_float(T::Rgba8Uint, |_| false), T::Rgba8Uint);
+        assert_eq!(
+            renderable_float(T::Rgb10a2Unorm, |_| false),
+            T::Rgb10a2Unorm
+        );
+    }
+
    #[test]
    fn samplers_read_custom_textures_of_their_type() {
        use wgpu::TextureSampleType as T;
@@ -5343,3 +5664,18 @@ mod const_offset_tests;

 #[cfg(test)]
 mod integer_colortex0_tests;
+
+#[cfg(test)]
+mod atlas_mip_tests;
+
+#[cfg(test)]
+mod wrong_type_uniform_tests;
+
+#[cfg(test)]
+mod atlas_name_post_tests;
+
+#[cfg(test)]
+mod unknown_sampler_terrain_tests;
+
+#[cfg(test)]
+mod mipmap_box_tests;
@@ -9,7 +9,9 @@ fn vs_full(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
 }

@group(0) @binding(0) var source: texture_2d<f32>;
-@group(0) @binding(1) var world_depth: texture_depth_2d;
+// A depth view read as an unfilterable float: naga's GLSL backend cannot
+// `textureLoad` a depth texture, and the texel is the same either way.
+@group(0) @binding(1) var world_depth: texture_2d<f32>;

 struct World {
    @location(0) color: vec4<f32>,
@@ -24,7 +26,7 @@ fn fs_blit(@builtin(position) p: vec4<f32>) -> World {
    let at = vec2<i32>(i32(p.x), size.y - 1 - i32(p.y));
    var out: World;
    out.color = textureLoad(source, at, 0);
-    out.depth = 1.0 - textureLoad(world_depth, at, 0);
+    out.depth = 1.0 - textureLoad(world_depth, at, 0).r;
    return out;
 }

@@ -49,15 +51,51 @@ fn vs_uv(@builtin(vertex_index) i: u32) -> Full {
    return Full(vec4<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, 0.0, 1.0), vec2<f32>(uv.x, 1.0 - uv.y));
 }

+// The screen's own rows: a picture a shader pack's `final` drew (not a GL-rows buffer).
+@vertex
+fn vs_screen(@builtin(vertex_index) i: u32) -> Full {
+    let uv = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
+    return Full(vec4<f32>(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, 0.0, 1.0), uv);
+}
+
@fragment
 fn fs_copy(v: Full) -> @location(0) vec4<f32> {
    return textureSample(source, linear, v.uv);
 }

-// One level of a buffer's mip chain from the level above (6.1.7): the average of the 2×2
-// texels under each destination texel, by one bilinear sample at their shared corner.
+// One level of a buffer's mip chain from the level above (6.1.7): a box filter, the average
+// of the texels under each destination texel (OpenGL 4.6, 8.14.4, recommends one). Along an
+// even side a texel covers two of the level above; along an odd side of 2d + 1 texels, texel i
+// covers 2 + 1 / d of them: 2i, 2i + 1 and 2i + 2, weighted d - i, d and i + 1 over 2d + 1.
+// Every texel of the level above then counts as much, so a small bright spot keeps its share
+// down to the last level, which is the buffer's mean.
+fn down_weights(i: u32, side: u32) -> vec3<f32> {
+    if side == 1u {
+        return vec3<f32>(1.0, 0.0, 0.0);
+    }
+    if side % 2u == 0u {
+        return vec3<f32>(0.5, 0.5, 0.0);
+    }
+    let d = f32(side / 2u);
+    return vec3<f32>(d - f32(i), d, f32(i) + 1.0) / f32(side);
+}
+
@fragment
 fn fs_down(@builtin(position) p: vec4<f32>) -> @location(0) vec4<f32> {
-    let size = max(textureDimensions(source) / 2u, vec2<u32>(1u));
-    return textureSampleLevel(source, linear, p.xy / vec2<f32>(size), 0.0);
+    let above = textureDimensions(source);
+    let at = vec2<u32>(p.xy);
+    let wx = down_weights(at.x, above.x);
+    let wy = down_weights(at.y, above.y);
+    let first = vec2<i32>(at * 2u);
+    let last = vec2<i32>(above) - 1;
+    var sum = vec4<f32>(0.0);
+    for (var y = 0; y < 3; y++) {
+        for (var x = 0; x < 3; x++) {
+            let w = wx[x] * wy[y];
+            if w > 0.0 {
+                sum += w * textureLoad(source, min(first + vec2<i32>(x, y), last), 0);
+            }
+        }
+    }
+    return sum;
 }
@@ -0,0 +1,108 @@
+//! The block atlas is read with nearest texels, blended between the two nearest levels: our
+//! probe packs (#9307) read `gtexture` in gbuffers_terrain, and the atlas as a custom texture in
+//! composite, at levels 0.5 and 1.25 in Iris 1.11.7, and got the two nearest levels mixed.
+use super::destination_tests::Fixture;
+use super::*;
+use std::io::{Cursor, Write};
+
+const VERTEX: &str = "#version 120\nvarying vec2 uv;\nvoid main() { uv = gl_MultiTexCoord0.xy; gl_Position = ftransform(); }\n";
+
+/// The atlas as composite's `noisetex`, read at levels 0.5 (red) and 0.25 (green).
+fn pack() -> Post {
+    let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    let mut add = |name: &str, source: &str| {
+        zip.start_file(name, zip::write::SimpleFileOptions::default())
+            .unwrap();
+        zip.write_all(source.as_bytes()).unwrap();
+    };
+    add(
+        "shaders/shaders.properties",
+        "texture.composite.noisetex=minecraft:textures/atlas/blocks.png\n",
+    );
+    add("shaders/composite.vsh", VERTEX);
+    add(
+        "shaders/composite.fsh",
+        "#version 130\nuniform sampler2D noisetex;\nvoid main() {\n/* DRAWBUFFERS:0 */\n\
+         \x20   gl_FragData[0] = vec4(textureLod(noisetex, vec2(0.5), 0.5).r, textureLod(noisetex, vec2(0.5), 0.25).r, 0.0, 1.0);\n}\n",
+    );
+    let pack = horizon_shaders::Pack::from_zip_bytes(
+        "original-atlas-levels",
+        zip.finish().unwrap().into_inner(),
+    )
+    .unwrap();
+    let mut macros = horizon_shaders::Macros::standard();
+    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
+    horizon_shaders::load_post(&pack, "", &properties, &macros, &Default::default())
+}
+
+/// A 4x4 atlas whose first level is black and second white.
+fn atlas(gpu: &Fixture) -> wgpu::TextureView {
+    let texture = gpu.device.create_texture(&wgpu::TextureDescriptor {
+        label: Some("Original two-level atlas"),
+        size: wgpu::Extent3d {
+            width: 4,
+            height: 4,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 2,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Rgba8Unorm,
+        usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+        view_formats: &[],
+    });
+    for (level, side, value) in [(0u32, 4u32, 0u8), (1, 2, 255)] {
+        gpu.queue.write_texture(
+            wgpu::TexelCopyTextureInfo {
+                texture: &texture,
+                mip_level: level,
+                origin: wgpu::Origin3d::ZERO,
+                aspect: wgpu::TextureAspect::All,
+            },
+            &[value, value, value, 255].repeat((side * side) as usize),
+            wgpu::TexelCopyBufferLayout {
+                offset: 0,
+                bytes_per_row: Some(side * 4),
+                rows_per_image: None,
+            },
+            wgpu::Extent3d {
+                width: side,
+                height: side,
+                depth_or_array_layers: 1,
+            },
+        );
+    }
+    texture.create_view(&Default::default())
+}
+
+#[test]
+fn the_atlas_blends_its_two_nearest_levels() {
+    let Some(gpu) = Fixture::new() else { return };
+    // The pack reads no lightmap: any texture serves.
+    let lightmap = atlas(&gpu);
+    let mut post = PackPost::new(
+        &gpu.device,
+        &gpu.queue,
+        &gpu.adapter,
+        pack(),
+        wgpu::TextureFormat::Rgba8Unorm,
+        World {
+            atlas: Some((atlas(&gpu), [4, 4])),
+            material_maps: None,
+            lightmap,
+            terrain: None,
+            block_ids: &[],
+            sprite_rects: &[],
+            celestial: None,
+            gui_size: [16, 16],
+            clouds: None,
+            weather: false,
+            hand: false,
+        },
+    )
+    .expect("the pack runs");
+    for p in gpu.render(&mut post, [4, 4]) {
+        // Half of white, and a quarter (within the blend's 8-bit weight).
+        assert!(p[0].abs_diff(128) <= 2 && p[1].abs_diff(64) <= 2, "{p:?}");
+    }
+}
@@ -0,0 +1,74 @@
+//! In deferred, composite and final programs the atlas's sampler names (`gtexture`, `tex`,
+//! `texture`) and names the game gives no texture read texture unit 0, which OptiFine's
+//! shaders.txt gives to `colortex0` there. Our probe packs (#9307) read the scene in `colortex0`
+//! through each in Iris 1.11.7, also in programs that don't declare `colortex0`.
+use super::destination_tests::Fixture;
+use super::*;
+use std::io::{Cursor, Write};
+
+const VERTEX: &str = "#version 120\nvarying vec2 uv;\nvoid main() { uv = gl_MultiTexCoord0.xy; gl_Position = ftransform(); }\n";
+
+/// deferred writes a colour into colortex0; composite reads it through `gtexture` into
+/// colortex1, composite1 through `tex` into colortex2, composite2 through a name of its own into
+/// colortex3; final shows them in that order, left to right, then what its own `texture` reads.
+fn pack() -> Post {
+    let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    let mut add = |name: &str, source: &str| {
+        zip.start_file(
+            format!("shaders/{name}"),
+            zip::write::SimpleFileOptions::default(),
+        )
+        .unwrap();
+        zip.write_all(source.as_bytes()).unwrap();
+    };
+    for program in ["deferred", "composite", "composite1", "composite2", "final"] {
+        add(&format!("{program}.vsh"), VERTEX);
+    }
+    add(
+        "deferred.fsh",
+        "#version 120\nvoid main() {\n/* DRAWBUFFERS:0 */\n    gl_FragData[0] = vec4(0.0, 200.0 / 255.0, 40.0 / 255.0, 1.0);\n}\n",
+    );
+    add(
+        "composite.fsh",
+        "#version 130\nuniform sampler2D gtexture;\nvarying vec2 uv;\nvoid main() {\n/* DRAWBUFFERS:1 */\n    gl_FragData[0] = texture(gtexture, uv);\n}\n",
+    );
+    add(
+        "composite1.fsh",
+        "#version 130\nuniform sampler2D tex;\nvarying vec2 uv;\nvoid main() {\n/* DRAWBUFFERS:2 */\n    gl_FragData[0] = texture(tex, uv);\n}\n",
+    );
+    add(
+        "composite2.fsh",
+        "#version 130\nuniform sampler2D probeOwnName;\nvarying vec2 uv;\nvoid main() {\n/* DRAWBUFFERS:3 */\n    gl_FragData[0] = texture(probeOwnName, uv);\n}\n",
+    );
+    add(
+        "final.fsh",
+        "#version 120\nuniform sampler2D texture;\nuniform sampler2D colortex1;\nuniform sampler2D colortex2;\n\
+         uniform sampler2D colortex3;\nvarying vec2 uv;\nvoid main() {\n\
+         \x20   gl_FragColor = uv.x < 0.25 ? texture2D(colortex1, uv) : uv.x < 0.5 ? texture2D(colortex2, uv)\n\
+         \x20       : uv.x < 0.75 ? texture2D(colortex3, uv) : texture2D(texture, uv);\n}\n",
+    );
+    let pack = horizon_shaders::Pack::from_zip_bytes(
+        "original-atlas-names-in-post",
+        zip.finish().unwrap().into_inner(),
+    )
+    .unwrap();
+    let mut macros = horizon_shaders::Macros::standard();
+    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
+    horizon_shaders::load_post(&pack, "", &properties, &macros, &Default::default())
+}
+
+#[test]
+fn atlas_names_read_colortex0_in_deferred_composite_and_final() {
+    let Some(gpu) = Fixture::new() else { return };
+    let mut post = gpu.build(pack());
+    let pixels = gpu.render(&mut post, [8, 8]);
+    for (i, p) in pixels.iter().enumerate() {
+        let name = match i % 8 {
+            0..2 => "gtexture in composite",
+            2..4 => "tex in composite1",
+            4..6 => "a name of the pack's in composite2",
+            _ => "texture in final",
+        };
+        assert_eq!(*p, [0, 200, 40, 255], "{name}, pixel {i}");
+    }
+}
@@ -22,7 +22,7 @@ fn hdr_pack(sized: bool, format: &str) -> Post {
        add(
            &format!("{program}.fsh"),
            &format!(
-                "#version 120\n/* RENDERTARGETS:{buffer} */\n/* const int colortex{buffer}Format={format}; */\nvoid main() {{ gl_FragData[0]=vec4(0,0.5,0,1); }}\n"
+                "#version 120\n/* RENDERTARGETS:{buffer} */\n/*\nconst int colortex{buffer}Format={format};\n*/\nvoid main() {{ gl_FragData[0]=vec4(0,0.5,0,1); }}\n"
            ),
        );
        if sized {
@@ -62,6 +62,16 @@ fn hdr_pack(sized: bool, format: &str) -> Post {
    post
 }

+// Check the fixture contract even when the render tests cannot find an adapter.
+#[test]
+fn clear_fixture_loads_the_requested_formats_without_a_gpu() {
+    for sized in [false, true] {
+        for format in ["RGBA16F", "RGBA8"] {
+            hdr_pack(sized, format);
+        }
+    }
+}
+
 fn hdr_clear_case(sized: bool, attachment_limit: u32, byte_budget: u32, format: &str) {
    let instance = crate::gfx::test_gpu::instance();
    let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
@@ -0,0 +1,76 @@
+//! A custom uniform of `shaders.properties` that the GLSL declares with another type: an original
+//! probe (#9307). In Iris 1.11.7 our probe packs read 0 for a float custom uniform declared `int`,
+//! an int declared `float`, a vec3 declared `vec2` and a vec2 declared `vec3`, and the uniform's
+//! own value where the types agree. A float of 2.5 declared `bool` read true (Iris logged it as
+//! disabled, but it read true in both games).
+use super::destination_tests::Fixture;
+use super::*;
+use std::io::{Cursor, Write};
+
+const VERTEX: &str = "#version 120\nvarying vec2 uv;\nvoid main() { uv=gl_MultiTexCoord0.xy; gl_Position=ftransform(); }\n";
+
+fn pack() -> Post {
+    let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    let mut add = |name: &str, source: &str| {
+        zip.start_file(
+            format!("shaders/{name}"),
+            zip::write::SimpleFileOptions::default(),
+        )
+        .unwrap();
+        zip.write_all(source.as_bytes()).unwrap();
+    };
+    add(
+        "shaders.properties",
+        "uniform.float.floatAsInt = 7.0\n\
+         uniform.int.intAsFloat = 7\n\
+         uniform.vec3.vec3AsVec2 = vec3(1.0, 2.0, 3.0)\n\
+         uniform.vec2.vec2AsVec3 = vec2(4.0, 5.0)\n\
+         uniform.float.floatAsFloat = 0.5\n\
+         uniform.int.intAsInt = 3\n\
+         uniform.float.floatAsBool = 2.5\n",
+    );
+    add("final.vsh", VERTEX);
+    // Pixel column x shows case x % 7 in red.
+    add(
+        "final.fsh",
+        "#version 330 compatibility\n\
+         uniform int floatAsInt;\nuniform float intAsFloat;\nuniform vec2 vec3AsVec2;\n\
+         uniform vec3 vec2AsVec3;\nuniform float floatAsFloat;\nuniform int intAsInt;\n\
+         uniform bool floatAsBool;\n\
+         void main() {\n    int x = int(gl_FragCoord.x) % 7;\n    float o = 0.0;\n\
+             if (x == 0) o = float(floatAsInt) / 10.0;\n\
+             else if (x == 1) o = intAsFloat / 10.0;\n\
+             else if (x == 2) o = (vec3AsVec2.x + vec3AsVec2.y) / 10.0;\n\
+             else if (x == 3) o = (vec2AsVec3.x + vec2AsVec3.y) / 10.0;\n\
+             else if (x == 4) o = floatAsFloat;\n\
+             else if (x == 5) o = float(intAsInt) / 10.0;\n\
+             else o = floatAsBool ? 1.0 : 0.0;\n\
+             gl_FragColor = vec4(o, 0.0, 0.0, 1.0);\n}\n",
+    );
+    let pack = horizon_shaders::Pack::from_zip_bytes(
+        "original-custom-types",
+        zip.finish().unwrap().into_inner(),
+    )
+    .unwrap();
+    let mut macros = horizon_shaders::Macros::standard();
+    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
+    let post = horizon_shaders::load_post(&pack, "", &properties, &macros, &Default::default());
+    assert_eq!(post.programs.len(), 1, "{:?}", post.notes);
+    post
+}
+
+#[test]
+fn a_custom_uniform_declared_with_another_type_reads_zero() {
+    let Some(gpu) = Fixture::new() else { return };
+    let Ok(mut post) = gpu.try_build(pack()) else {
+        panic!("the pack runs")
+    };
+    let pixels = gpu.render(&mut post, [7, 1]);
+    let red: Vec<u8> = pixels[..7].iter().map(|p| p[0]).collect();
+    // 0 for the four mismatches, 0.5 and 0.3 where the types agree, then true.
+    let want = [0.0, 0.0, 0.0, 0.0, 0.5, 0.3, 1.0].map(|v: f32| (v * 255.0).round() as u8);
+    assert!(
+        red.iter().zip(want).all(|(g, w)| g.abs_diff(w) <= 1),
+        "{red:?}, expected {want:?}"
+    );
+}