Merge pull request #11637 from horizon-rust/fix/lightning-fire-radius-11376

🤖 Agent: lightning now places fire (and draws its extra-source offsets) only when canSpreadFireAround passes at the bolt, so fire_spread_radius_around_player holds for strikes far from every player.
Merge pull request #10065 from ilguerro/fix/thorns-victim
2026-11-07 17:21:49 -10:00 · 2026-11-07 07:40:30 +01:00 · 2026-11-07 07:19:55 +01:00 · 2026-11-07 07:18:08 +01:00 · 2026-11-07 07:05:28 +01:00 · 2026-11-07 06:58:08 +01:00
2081 changed files with 265111 additions and 24256 deletions
@@ -1,3 +1,4 @@
 self-hosted-runner:
  # The Mac mini's runner (ludovics-mac-mini), which holds the maintainer's own Minecraft files.
-  labels: [horizon-game, ludovics-mac-mini]
+  # windows-11-vs2026-arm is GitHub's Windows ARM64 image (2026-08), newer than actionlint's label list.
+  labels: [horizon-game, ludovics-mac-mini, windows-11-vs2026-arm]
@@ -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)
@@ -22,7 +22,7 @@ jobs:
    outputs:
      platforms: ${{ steps.platforms.outputs.platforms }}
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
      - id: platforms
        run: echo "platforms=$(python3 -c 'import json, tools.horizon_mod_binstall as m; print(json.dumps(m.PLATFORMS))')" >> "$GITHUB_OUTPUT"
  build:
@@ -35,7 +35,7 @@ jobs:
    runs-on: ${{ matrix.os }}
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
      - uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.target }}
@@ -67,7 +67,7 @@ jobs:
          [ -f "$binary.exe" ] && binary="$binary.exe"
          mkdir -p dist
          tar -czf "dist/$(basename "$binary" | sed 's/\.exe$//')-${{ matrix.target }}.tar.gz" -C "$(dirname "$binary")" "$(basename "$binary")"
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
        with:
          name: cargo-horizon-mod-${{ matrix.target }}
          path: dist/*.tar.gz
@@ -81,8 +81,8 @@ jobs:
    permissions:
      contents: write
    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v4
+      - uses: actions/checkout@v7
+      - uses: actions/download-artifact@v8
        with:
          pattern: cargo-horizon-mod-*
          path: dist
@@ -41,10 +41,10 @@ jobs:
      fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v7
        if: runner.environment == 'github-hosted'
        with:
          python-version: '3.12'
@@ -126,7 +126,7 @@ jobs:
      fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
    timeout-minutes: 45
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
      - name: Does this pull request change the launcher or a crate it builds?
@@ -158,7 +158,103 @@ 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
+  # 90-minute job. The Nightly and launcher releases build and check these binaries on every run.
+  windows-arm64:
+    name: Windows ARM64 game and launcher
+    if: github.event_name == 'workflow_dispatch'
+    runs-on: windows-11-vs2026-arm
+    timeout-minutes: 90
+    env:
+      RUSTFLAGS: -C target-feature=+crt-static
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+      - name: Use every runner core for Cargo
+        shell: pwsh
+        run: |
+          $cores = (Get-CimInstance Win32_Processor | Measure-Object -Property NumberOfLogicalProcessors -Sum).Sum
+          "CARGO_BUILD_JOBS=$cores" >> $env:GITHUB_ENV
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: aarch64-pc-windows-msvc
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: windows-arm64-game
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: launcher
+          shared-key: windows-arm64-launcher
+      - name: Check LLVM assembler used by ring
+        shell: pwsh
+        run: |
+          $llvmBin = Join-Path $env:ProgramFiles 'LLVM\bin'
+          if (-not (Get-Command clang -ErrorAction SilentlyContinue) -and (Test-Path (Join-Path $llvmBin 'clang.exe'))) {
+            $env:PATH = "$llvmBin;$env:PATH"
+            "PATH=$env:PATH" >> $env:GITHUB_ENV
+          }
+          $clang = Get-Command clang -ErrorAction Stop
+          Write-Output "Using $($clang.Source)"
+          & $clang.Source --version
+      - name: Build the game for native Windows ARM64
+        run: cargo build --release --locked --target aarch64-pc-windows-msvc -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: Check the game's PE machine
+        run: python tools/check_pe_arch.py arm64 target/aarch64-pc-windows-msvc/release/horizon-client.exe target/aarch64-pc-windows-msvc/release/horizon-ctl.exe target/aarch64-pc-windows-msvc/release/horizon-prepare.exe target/aarch64-pc-windows-msvc/release/horizon-server.exe
+      - name: Check game DLL imports
+        run: python tools/check_imports.py target/aarch64-pc-windows-msvc/release/horizon-client.exe target/aarch64-pc-windows-msvc/release/horizon-ctl.exe target/aarch64-pc-windows-msvc/release/horizon-prepare.exe target/aarch64-pc-windows-msvc/release/horizon-server.exe
+      - name: Start every game executable
+        shell: pwsh
+        run: |
+          $ErrorActionPreference = 'Stop'
+          $client = 'target/aarch64-pc-windows-msvc/release/horizon-client.exe'
+          $output = & $client --help 2>&1
+          if ($LASTEXITCODE -ne 0 -or ($output -join "`n") -notmatch '--resources') { throw 'horizon-client --help failed' }
+          foreach ($binary in @('horizon-ctl.exe', 'horizon-prepare.exe', 'horizon-server.exe')) {
+            $path = "target/aarch64-pc-windows-msvc/release/$binary"
+            $output = & $path --help 2>&1
+            if ($LASTEXITCODE -ne 0 -or -not $output) { throw "$binary --help failed" }
+          }
+          foreach ($binary in @('horizon-prepare.exe', 'horizon-server.exe')) {
+            $path = "target/aarch64-pc-windows-msvc/release/$binary"
+            $output = & $path --version 2>&1
+            if ($LASTEXITCODE -ne 0 -or -not $output) { throw "$binary --version failed" }
+            Write-Output ($output -join "`n")
+          }
+      - name: Test and build the native Windows ARM64 launcher
+        working-directory: launcher
+        run: |
+          cargo test --release --locked --target aarch64-pc-windows-msvc --lib
+          cargo build --release --locked --target aarch64-pc-windows-msvc
+      - name: Check the launcher's PE machine
+        working-directory: launcher
+        run: python ../tools/check_pe_arch.py arm64 target/aarch64-pc-windows-msvc/release/horizon-launcher.exe
+      - name: Check launcher DLL imports and command-line startup
+        working-directory: launcher
+        # bash, as launcher.yml's check on the same runner: the launcher is a GUI-subsystem program, and a pwsh
+        # `$output = & launcher --version` read no output from it (run 42217014588).
+        shell: bash
+        run: |
+          launcher=target/aarch64-pc-windows-msvc/release/horizon-launcher.exe
+          python ../tools/check_imports.py "$launcher"
+          out=$("$launcher" --version)
+          echo "$out"
+          [[ "$out" == "horizon-launcher "* ]] || { echo "::error::horizon-launcher --version printed '$out'"; exit 1; }
+      - 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).
@@ -169,7 +265,7 @@ jobs:
    outputs:
      run: ${{ steps.scope.outputs.run }}
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          ref: ${{ github.event.pull_request.head.sha }}
          fetch-depth: 0
@@ -181,7 +277,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
@@ -196,6 +292,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
@@ -204,13 +301,13 @@ jobs:
    if: github.event_name == 'workflow_dispatch'
    runs-on: [self-hosted, linux, horizon-game]
    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
        with:
          python-version: '3.12'
      - name: Install Rust toolchain
        run: rustup toolchain install stable --profile minimal
-      - uses: actions/setup-java@v4
+      - uses: actions/setup-java@v6
        with:
          distribution: temurin
          java-version: '25'
@@ -552,11 +649,11 @@ jobs:
    if: github.event_name == 'workflow_dispatch'
    runs-on: [self-hosted, linux, horizon-game]
    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
        with:
          python-version: '3.12'
-      - uses: actions/setup-java@v4
+      - uses: actions/setup-java@v6
        with:
          distribution: temurin
          java-version: '25'
@@ -36,7 +36,7 @@ jobs:
      contents: read
      issues: write
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          ref: main
          persist-credentials: false
@@ -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 }}
@@ -63,7 +65,7 @@ jobs:
      contents: read
      issues: write
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          ref: main
          persist-credentials: false
@@ -1,6 +1,6 @@
 name: game build
-# Builds the game for every platform from `ref`: the Java exporters, then Linux and the Linux server and Windows on
-# GitHub, macOS on the Mac mini's runner with a 1500-frame offscreen run of a new world (smoke-test.json): Apple
+# Builds the game for every platform from `ref`: the Java exporters, then Linux and the Linux server, Windows x64
+# and ARM64 on GitHub, and macOS on the Mac mini's runner with a 1500-frame offscreen run of a new world (smoke-test.json): Apple
 # Silicon, and Intel cross-built there for x86_64-apple-darwin and checked under Rosetta 2 (#1161). Called by
 # release.yml (the releases) and nightly-build.yml (the opt-in Nightly), always from main's copy of this file: the
 # caller's commit, never the one being built. It holds no secrets: signing the checksums is the callers' own job,
@@ -45,7 +45,7 @@ jobs:
    # Three full preparations (two isolated, one batched) besides the compile.
    timeout-minutes: 60
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          ref: ${{ inputs.ref }}
          persist-credentials: false
@@ -73,7 +73,7 @@ jobs:
            ! \( -name '*.class' \( -path 'exporters/server/dev/horizonlab/parity/*' -o -path 'exporters/client/dev/horizonlab/parity/*' \) \))
          [ -z "$stray" ] || { echo "::error::not one of our classes: $stray"; exit 1; }
          python3 tools/check_prepare_exporters.py --binary target/release/horizon-prepare
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
        with:
          name: original-exporters
          path: exporters/
@@ -83,6 +83,10 @@ jobs:
  build:
    needs: exporters
    name: build ${{ matrix.name }}
+    # 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
+    # optional archives out with a warning.
+    continue-on-error: ${{ matrix.name == 'windows-arm64' || matrix.name == 'linux-musl' }}
    strategy:
      fail-fast: false
      matrix:
@@ -94,13 +98,28 @@ 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
            asset: horizon-windows-x64.zip
            exe: .exe
+            pe_arch: x64
            # The C runtime linked in, so the game runs without the Visual C++ redistributable.
            rustflags: -C target-feature=+crt-static
+          - name: windows-arm64
+            os: windows-11-vs2026-arm
+            target: aarch64-pc-windows-msvc
+            dir: horizon-windows-arm64
+            asset: horizon-windows-arm64.zip
+            exe: .exe
+            pe_arch: arm64
+            # The ARM64 runner builds and runs native ARM64 executables; keep the C runtime in the archive.
+            rustflags: -C target-feature=+crt-static
          - name: macos
            mac: true
            dir: horizon-macos-arm64
@@ -128,7 +147,7 @@ jobs:
      run:
        shell: bash
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          ref: ${{ inputs.ref }}
          persist-credentials: false
@@ -141,21 +160,29 @@ 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; }
          done
+      - name: Verify Windows executable architecture
+        if: runner.os == 'Windows'
+        run: |
+          python tools/check_pe_arch.py "${{ matrix.pe_arch }}" \
+            "$BIN/horizon-client${{ matrix.exe }}" "$BIN/horizon-ctl${{ matrix.exe }}" \
+            "$BIN/horizon-prepare${{ matrix.exe }}" "$BIN/horizon-server${{ matrix.exe }}"
      - name: The signing keychain, unlocked
        if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' && inputs.developer_id
        env:
@@ -173,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: |
@@ -188,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'
+        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
@@ -239,18 +268,26 @@ jobs:
          # Published with the release; the publish job checks it again before it publishes anything.
          cp "$home/smoke.json" "$RUNNER_TEMP/smoke-test.json"
      # One smoke-test.json per build, the Apple Silicon one's; the Intel build must pass its own run too.
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
        if: runner.environment == 'self-hosted' && !matrix.target
        with:
          name: smoke-test.json
          path: ${{ runner.temp }}/smoke-test.json
          if-no-files-found: error
          retention-days: 3
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
        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 }}"
@@ -277,7 +314,7 @@ jobs:
            codesign --verify --strict "dist/${{ matrix.dir }}/$binary"
          done
          packaging/macos/notarize.sh "dist/${{ matrix.asset }}"
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
        with:
          name: ${{ matrix.asset }}
          path: dist/${{ matrix.asset }}
@@ -299,7 +336,7 @@ jobs:
          rm -f "${{ matrix.server_asset }}"
          tar czf "${{ matrix.server_asset }}" "${{ matrix.server_dir }}"
          ls -l "${{ matrix.server_asset }}"
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
        if: matrix.server_asset
        with:
          name: ${{ matrix.server_asset }}
@@ -1,5 +1,5 @@
 name: launcher
-# Builds the launcher on Linux, macOS and Windows, and releases it by itself (docs/release-flow.md): after a
+# Builds the launcher on Linux, macOS, Windows x64 and ARM64, and releases it by itself (docs/release-flow.md): after a
 # push to main that changes the launcher or a crate it builds in (the paths below),
 # every 10 minutes (a release waiting for merges to settle goes out) and by hand, tools/release_train.py decides as
 # for the game.
@@ -15,8 +15,9 @@ name: launcher
 # under Rosetta 2 (#1161). With the repository variable MACOS_SIGN_IDENTITY set, Horizon.app and the .dmg are signed with
 # Developer ID, notarized and stapled, from the runner's signing keychain (packaging/macos/README.md);
 # unset (forks), they are signed ad hoc.
-# Windows ships the launcher's own binary twice: in the ZIP (what a launcher updates itself from) and as
-# horizon-launcher-setup.exe, which opens the per-user installer instead of Home (launcher/src/installer.rs).
+# Windows ships each architecture's launcher in its ZIP (what a launcher updates itself from) and as
+# horizon-launcher-setup.exe or horizon-launcher-setup-arm64.exe, which opens the per-user installer instead of Home
+# (launcher/src/installer.rs).
 #   gh workflow run launcher --ref <branch>                    # dry run: builds everything, publishes nothing
 #   gh workflow run launcher --ref main -f dry_run=false -f force=true

@@ -73,7 +74,7 @@ jobs:
      version: ${{ steps.decide.outputs.version }}
      dry_run: ${{ steps.mode.outputs.dry_run }}
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
      - id: mode
@@ -102,6 +103,10 @@ jobs:
    needs: decide
    if: needs.decide.outputs.release == 'true'
    name: build ${{ matrix.name }}
+    # Windows ARM64 is new: its 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' }}
    strategy:
      fail-fast: false
      matrix:
@@ -125,9 +130,20 @@ jobs:
            os: windows-latest
            asset: horizon-launcher-windows-x64.zip
            binary: horizon-launcher.exe
+            pe_arch: x64
+            setup_asset: horizon-launcher-setup.exe
            # The C runtime linked in: without it the launcher asks for VCRUNTIME140.dll,
            # which only the Visual C++ redistributable installs.
            rustflags: -C target-feature=+crt-static
+          - name: windows-arm64
+            os: windows-11-vs2026-arm
+            target: aarch64-pc-windows-msvc
+            asset: horizon-launcher-windows-arm64.zip
+            binary: horizon-launcher.exe
+            pe_arch: arm64
+            setup_asset: horizon-launcher-setup-arm64.exe
+            # The C runtime linked in, so the standalone ARM64 launcher needs no redistributable.
+            rustflags: -C target-feature=+crt-static
    runs-on: ${{ matrix.mac && (vars.MAC_RUNNER || 'ludovics-mac-mini') || matrix.os }}
    # Notarizing the app and then the .dmg can take a few minutes each.
    timeout-minutes: ${{ matrix.mac && 60 || 40 }}
@@ -150,7 +166,7 @@ jobs:
        working-directory: launcher
        shell: bash
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          ref: ${{ needs.decide.outputs.head }}
          persist-credentials: false
@@ -182,6 +198,9 @@ jobs:
      # Every test target (the library, the binary, tests/), on each system the launcher ships for.
      - run: cargo test --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
      - run: cargo build --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
+      - name: Verify Windows executable architecture
+        if: runner.os == 'Windows'
+        run: python ../tools/check_pe_arch.py "${{ matrix.pe_arch }}" "$BIN/${{ matrix.binary }}"
      - name: The version is the release's
        run: |
          out=$("$BIN/${{ matrix.binary }}" --version)
@@ -212,7 +231,8 @@ jobs:
          "$launcher" links --json
          # The Intel Mac launcher can come out before any game build has its asset (#1161): then there is nothing
          # to install yet. Only that entry skips, and only on a version list that parsed and had no build here
-          # (exit 3); a launcher or a script that fails still fails the step.
+          # (exit 3); a launcher or a script that fails still fails the step. The Windows ARM64 launcher always has
+          # one: it installs the x64 build where a release has no ARM64 one (backend.rs, GAME_FALLBACK).
          if [[ "${{ matrix.name }}" == macos-x64 ]]; then
            versions=$(retry "$launcher" --json versions)
            no_build='import json, sys; sys.exit(3 if not any(r["available_here"] for r in json.load(sys.stdin)) else 0)'
@@ -236,6 +256,11 @@ jobs:
          # release linked to a Nix store is a warning here, not a broken launcher.
          soft() { if [[ "$RUNNER_OS" == "Linux" ]]; then "$@" || echo "::warning::$* failed"; else "$@"; fi; }
          if [[ "$RUNNER_OS" == "Windows" ]]; then
+            if ! python ../tools/check_pe_arch.py "${{ matrix.pe_arch }}" "$client"; then
+              # A Nightly without an ARM64 build: the ARM64 launcher installs the x64 one (backend.rs, GAME_FALLBACK).
+              [[ "${{ matrix.pe_arch }}" == arm64 ]] && python ../tools/check_pe_arch.py x64 "$client" || exit 1
+              echo "::warning::the latest game has no ARM64 build: the launcher installed the x64 one"
+            fi
            python ../tools/check_imports.py "$client"
          elif [[ "$RUNNER_OS" == "Linux" ]]; then
            soft python3 ../tools/check_imports.py "$client"
@@ -295,8 +320,8 @@ jobs:
        # installer instead of Home (launcher/src/installer.rs). Its name is what makes it the setup,
        # so the ZIP's copy stays the launcher. Both go into the release's signed SHA256SUMS.
        if: runner.os == 'Windows'
-        run: cp "$BIN/${{ matrix.binary }}" out/horizon-launcher-setup.exe
-      - uses: actions/upload-artifact@v4
+        run: cp "$BIN/${{ matrix.binary }}" "out/${{ matrix.setup_asset }}"
+      - uses: actions/upload-artifact@v7
        with:
          name: ${{ matrix.asset }}
          path: launcher/out/*
@@ -314,12 +339,12 @@ jobs:
    # tools/ci/sign_release.sh, which calls only the runner's sha256sum and OpenSSL (docs/release-flow.md).
    environment: ${{ needs.decide.outputs.dry_run != 'true' && 'release' || '' }}
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          sparse-checkout: tools/ci/sign_release.sh
          sparse-checkout-cone-mode: false
          persist-credentials: false
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
        with:
          path: dist
          pattern: horizon-launcher-*
@@ -331,13 +356,13 @@ jobs:
          EPHEMERAL: ${{ needs.decide.outputs.dry_run == 'true' && 'yes' || '' }}
          TAG: ${{ needs.decide.outputs.tag }}
        run: bash tools/ci/sign_release.sh "$TAG" dist/horizon-launcher-*
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
        with:
          name: signature
          path: dist/SHA256SUMS*
          if-no-files-found: error
          retention-days: 3
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
        if: needs.decide.outputs.dry_run == 'true'
        with:
          name: ephemeral.pub
@@ -351,7 +376,7 @@ jobs:
    permissions:
      contents: write
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
      - name: Notes
@@ -361,7 +386,7 @@ jobs:
          python3 tools/release_train.py notes --kind launcher --tag "${{ needs.decide.outputs.tag }}" \
            --head "${{ needs.decide.outputs.head }}" --out notes > /dev/null
          { echo "## $(cat notes/title.txt)"; echo; cat notes/body.md; } >> "$GITHUB_STEP_SUMMARY"
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
        with:
          path: dist
          merge-multiple: true
@@ -373,6 +398,13 @@ jobs:
          key=(); [[ -n "$EPHEMERAL" ]] && key=(--key "$(cat dist/ephemeral.pub)")
          cargo run --locked --quiet -p horizon-release-sign -- verify --tag "$TAG" --publishing "${key[@]}" dist
      # Never marked latest: Horizon's own releases stay the repository's latest.
+      - name: The Windows ARM64 launcher, if it built
+        # Its build may fail without holding the release (continue-on-error): the release then has no ARM64
+        # files, and ARM64 launchers stay on their version until one has (backend::launcher_update_from).
+        run: |
+          for file in horizon-launcher-windows-arm64.zip horizon-launcher-setup-arm64.exe; do
+            [[ -f "dist/$file" ]] || echo "::warning::$file is missing: this release goes out without it"
+          done
      - name: Publish ${{ needs.decide.outputs.tag }}
        if: needs.decide.outputs.dry_run != 'true'
        env:
@@ -387,7 +419,7 @@ jobs:
        run: |
          echo "Would publish ${{ needs.decide.outputs.tag }} at ${{ needs.decide.outputs.head }}: $(cat notes/title.txt)"
          ls -l dist
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
        with:
          name: launcher-release-notes
          path: notes/
@@ -27,7 +27,7 @@ jobs:
      run:
        working-directory: crates/horizon-mod-registry
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
      - run: rustup toolchain install stable --profile minimal --component rustfmt --component clippy
      # Ours keep their build folder between jobs.
      - uses: Swatinem/rust-cache@v2
@@ -25,7 +25,7 @@ jobs:
    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && fromJSON('["self-hosted", "linux", "horizon-light"]') || 'ubuntu-latest' }}
    timeout-minutes: 10
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
      - name: Check the manifest
        env:
          GH_TOKEN: ${{ github.token }}
@@ -24,7 +24,7 @@ jobs:
      pull-requests: write
    timeout-minutes: 10
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          ref: main
          fetch-depth: 0
@@ -52,4 +52,8 @@ jobs:
            git fetch origin "+refs/heads/$branch:refs/remotes/origin/$branch"
          fi
          git push --force-with-lease origin "$branch"
-          gh pr create --base main --head "$branch" --title 'Stamp native hook API fragments' --body 'Assign API numbers to the pending native hook fragments. Close and reopen this PR to run CI.'
+          # The repo doesn't let GitHub Actions open pull requests (that setting would also let it approve them):
+          # the branch is pushed, and a maintainer opens the PR from it.
+          if ! gh pr create --base main --head "$branch" --title 'Stamp native hook API fragments' --body 'Assign API numbers to the pending native hook fragments. Close and reopen this PR to run CI.'; then
+            echo "::warning::Stamped fragments are on $branch; open a pull request from it (GitHub Actions may not open one here)."
+          fi
@@ -92,7 +92,7 @@ jobs:
      source_tag: ${{ steps.pick.outputs.source_tag }}
      dry_run: ${{ steps.mode.outputs.dry_run }}
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
          persist-credentials: false
@@ -124,14 +124,14 @@ jobs:
        env:
          SHA: ${{ steps.pick.outputs.sha }}
        run: git archive --format=tar.gz --prefix="horizon-${SHA:0:7}/" -o horizon-source.tar.gz "$SHA"
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
        if: steps.pick.outputs.build == 'true'
        with:
          name: horizon-source
          path: horizon-source.tar.gz
          if-no-files-found: error
          retention-days: 3
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
        with:
          name: nightly-notes
          path: nightly-notes.md
@@ -155,32 +155,42 @@ jobs:
    # The key's only job: main's sign_release.sh hashes the archives and signs with the runner's OpenSSL.
    environment: ${{ needs.pick.outputs.dry_run != 'true' && 'release' || '' }}
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          sparse-checkout: tools/ci/sign_release.sh
          sparse-checkout-cone-mode: false
          persist-credentials: false
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
        with:
          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[@]}" "${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@v4
+      - uses: actions/upload-artifact@v7
        with:
          name: signature
          path: dist/SHA256SUMS*
          if-no-files-found: error
          retention-days: 3
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
        if: needs.pick.outputs.dry_run == 'true'
        with:
          name: ephemeral.pub
@@ -195,19 +205,24 @@ jobs:
      contents: write
      issues: read          # the open release-blocker issues (gate)
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          persist-credentials: false
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
        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).
@@ -224,18 +239,37 @@ 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
+            arm64=("dist/horizon-windows-arm64.zip#Game files the launcher installs (Nightly): Windows ARM64 (horizon-windows-arm64.zip)")
+          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)" \
            "dist/horizon-macos-x64.zip#Game files the launcher installs (Nightly): macOS on Intel (horizon-macos-x64.zip)" \
            "dist/horizon-server-linux-x86_64.tar.gz#Nightly dedicated server for Linux (horizon-server-linux-x86_64.tar.gz)" \
@@ -27,7 +27,7 @@ jobs:
      issues: write         # answers in the thread
      pull-requests: write
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          ref: main
          persist-credentials: false
@@ -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
@@ -48,7 +48,7 @@ jobs:
          else
            echo "run=true" >> "$GITHUB_OUTPUT"
          fi
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        if: steps.when.outputs.run == 'true'
        with:
          fetch-depth: 0
@@ -82,7 +82,7 @@ jobs:
        run: python3 tools/ci/parity_issues.py --since "${{ steps.audit.outputs.since }}" ${{ inputs.dry_run && '--dry-run' || '' }} | tee -a "$GITHUB_STEP_SUMMARY"
      - name: Logs of the failed harnesses
        if: steps.when.outputs.run == 'true' && steps.audit.outputs.exit != '0'
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
        with:
          name: nightly-parity-logs
          path: .local/parity-runner/logs/
@@ -27,7 +27,7 @@ jobs:
      contents: read
      pull-requests: write
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          ref: main
          fetch-depth: 0
@@ -27,7 +27,7 @@ jobs:
    runs-on: ${{ vars.SELF_HOSTED_CI != 'off' && vars.SELF_HOSTED_CI != 'light' && fromJSON('["self-hosted", "linux", "horizon-checks"]') || 'ubuntu-latest' }}
    timeout-minutes: 90
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
      - name: Install Rust and the ALSA and udev headers
@@ -30,7 +30,7 @@ jobs:
    runs-on: [self-hosted, macOS, horizon-parity-main]
    timeout-minutes: 240  # a core-crate batch reruns ~300 harnesses (~60-90 min), a bisect a few rounds of the failures
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          ref: ${{ github.sha }}
          fetch-depth: 0
@@ -69,7 +69,7 @@ jobs:
          python3 tools/parity_main.py bisect "$BASE_SHA" --comment
      - name: Logs of the failed harnesses
        if: steps.harnesses.outcome == 'failure'
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
        with:
          name: parity-main-logs
          path: .local/parity-main-logs/
@@ -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:
@@ -33,7 +39,7 @@ jobs:
    # harnesses at a time) up to a few hours, and any pull request's job may land there.
    timeout-minutes: ${{ inputs.full && 360 || 180 }}
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          # The commit the event names: a fork's later pushes need another run-parity label. The next step merges
          # main into it.
@@ -87,9 +93,15 @@ 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@v4
+        uses: actions/upload-artifact@v7
        with:
          name: parity-logs
          path: .local/parity-runner/logs/
@@ -24,7 +24,7 @@ jobs:
      contents: read
      pull-requests: write
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          ref: main
          persist-credentials: false
@@ -53,7 +53,7 @@ jobs:
      urgent: ${{ steps.decide.outputs.urgent }}
      dry_run: ${{ steps.mode.outputs.dry_run }}
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
      - id: mode
@@ -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') }}
@@ -27,7 +27,7 @@ jobs:
      run:
        working-directory: crates/horizon-telemetry-server
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
      - run: rustup toolchain install stable --profile minimal --component rustfmt --component clippy
      # Ours keep their build folder between jobs.
      - uses: Swatinem/rust-cache@v2
@@ -29,7 +29,7 @@ jobs:
      issues: write
      pull-requests: write
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
        with:
          ref: main
          persist-credentials: false
@@ -43,6 +43,8 @@ jobs:
          GH_TOKEN: ${{ github.token }}
          BODY: ${{ github.event.comment.body }}
          AUTHOR: ${{ github.event.comment.user.login }}
+          # Who may act is decided by this numeric ID: a login can be claimed by someone else after a rename.
+          AUTHOR_ID: ${{ github.event.comment.user.id }}
          ISSUE: ${{ github.event.issue.number }}
          REPO: ${{ github.repository }}
          COMMENT_URL: ${{ github.event.comment.html_url }}
@@ -9,8 +9,10 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
 - **Never commit Mojang's files**: game jars, assets, decompiled source, prepared resources (`.local/`).
  `tools/check_public_tree.py` rejects them; `git config core.hooksPath .githooks` runs it on commit.
 - **Keep your runs away from real player data.** Any game or launcher you start gets fresh `mktemp -d`
-  folders in `HORIZON_HOME` (the game's data), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and
-  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`, and, for the
+  folders in `HORIZON_HOME` (logs, crash reports, telemetry consent, recordings; not saves), `HORIZON_LAUNCHER_HOME`, `XDG_DATA_HOME` and
+  `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`. Saves, `options.txt` and
+  caches go in the game folder, by default the working directory: start the game from a scratch folder with
+  `--game-dir` pointing at it, or they land in the repo root, hidden by `.gitignore`. For the
  launcher, `HORIZON_LAUNCHER_TRASH`, `HORIZON_LAUNCHER_CLIPBOARD` and `HORIZON_LAUNCHER_DESKTOP` pointing into the scratch home. Never write to
  `~/.local/share/{applications,horizon,horizon-launcher}` or `~/.local/bin`.
 - **Mark what an agent posts.** A PR body starts with a line naming the person whose agent opened it and
@@ -32,7 +34,10 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
 - Contributors first: `gh pr list --state open --search <area>` before you start; never duplicate theirs.
 - **No hardcoded user-facing strings.** Keep UI translation-ready from the start. In the launcher (`launcher/`), wrap visible text with `tr("...")` or `trf("... {arg} ...", &[("arg", &val)])` from `crate::i18n` instead of raw string literals or `format!`. In the game, use translation keys (`Text::tr`, `lang::get`), never hardcoded English strings.
 - **Claim before you start**: comment `/claim` on the issue (no issue yet: open one, then claim it). An assigned
-  issue is taken: pick another. `/unclaim` when you stop; a claim with no open PR linking it is released after 5 days.
+  issue is taken, and so is one labelled `in progress` (claimed on Discord): pick another. `/unclaim` when you stop;
+  a claim with no open PR linking it is released after 5 days. The issues free to claim, without reading threads:
+  `gh issue list --search 'is:open no:assignee -label:"in progress" -label:tracker -label:proposal -label:"not claimable" -linked:pr'`
+- **Controllers reach what registers.** Draw controls with a registering helper (`ui::button`, `settings_shell::foot_button`); `graphics_style::button` and `screen_draw::button` only paint, and registering one part of a screen ends its crosshair, so register all of it.

 ## Crates

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

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

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

+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
 [[package]]
 name = "byteorder-lite"
 version = "0.1.0"
@@ -458,6 +491,7 @@ checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
 dependencies = [
 "iana-time-zone",
 "num-traits",
+ "serde",
 "windows-link",
 ]

@@ -513,6 +547,12 @@ dependencies = [
 "unicode-width",
 ]

+[[package]]
+name = "color_quant"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+
 [[package]]
 name = "combine"
 version = "4.6.8"
@@ -651,6 +691,15 @@ dependencies = [
 "cfg-if",
 ]

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

+[[package]]
+name = "derive_utils"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc05a5d33db20c784f873e84934ad94bb209a090987ac5f62fede2c178234f23"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+
 [[package]]
 name = "des"
 version = "0.8.1"
@@ -899,6 +959,18 @@ version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7"

+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
 [[package]]
 name = "fdeflate"
 version = "0.3.7"
@@ -1058,8 +1130,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
 dependencies = [
 "cfg-if",
+ "js-sys",
 "libc",
 "wasi",
+ "wasm-bindgen",
 ]

 [[package]]
@@ -1088,6 +1162,16 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "gif"
+version = "0.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159"
+dependencies = [
+ "color_quant",
+ "weezl",
+]
+
 [[package]]
 name = "gilrs"
 version = "0.11.2"
@@ -1217,6 +1301,15 @@ dependencies = [
 "serde_core",
 ]

+[[package]]
+name = "hashlink"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a596f1b20ed2cc5ecac41a164aaebc7258057060f06c0cf7a2ba3991ee7990fb"
+dependencies = [
+ "hashbrown 0.17.1",
+]
+
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -1318,6 +1411,7 @@ dependencies = [
 "ab_glyph",
 "bytemuck",
 "chrono",
+ "dunce",
 "flate2",
 "fs4",
 "gilrs",
@@ -1363,6 +1457,7 @@ dependencies = [
 "serde_json",
 "sha1",
 "sha2",
+ "toml",
 "unicode-bidi",
 "ureq",
 "wgpu",
@@ -1400,6 +1495,7 @@ dependencies = [
 "chrono",
 "flate2",
 "fs4",
+ "getrandom 0.3.4",
 "gilrs",
 "glam",
 "horizon-anticheat",
@@ -1411,6 +1507,7 @@ dependencies = [
 "horizon-client-render",
 "horizon-command",
 "horizon-core",
+ "horizon-cosmetics",
 "horizon-dualsense",
 "horizon-friends",
 "horizon-hdr",
@@ -1605,6 +1702,21 @@ dependencies = [
 "serde_json",
 ]

+[[package]]
+name = "horizon-mod-deps"
+version = "0.1.0"
+dependencies = [
+ "gif",
+ "mysql",
+ "quinn",
+ "redis",
+ "rusqlite",
+ "rusty-opus",
+ "snap",
+ "tungstenite",
+ "yaml-rust2",
+]
+
 [[package]]
 name = "horizon-mods"
 version = "0.1.0"
@@ -1715,6 +1827,7 @@ dependencies = [
 "horizon-mcp",
 "horizon-release-sign",
 "horizon-server-files",
+ "horizon-world",
 "libc",
 "p12-keystore",
 "png",
@@ -1999,6 +2112,15 @@ dependencies = [
 "generic-array",
 ]

+[[package]]
+name = "io-enum"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f859dc81e05e585e93cfc84dffa4fd068d0651ca229c51bca6101c056b63b93a"
+dependencies = [
+ "derive_utils",
+]
+
 [[package]]
 name = "ipconfig"
 version = "0.3.4"
@@ -2197,6 +2319,17 @@ dependencies = [
 "redox_syscall 0.9.4",
 ]

+[[package]]
+name = "libsqlite3-sys"
+version = "0.39.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14a5f01b87b92705d07b433c06f96cbc764637d81a0bffb5734ce17cf0f9a2b3"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "libudev-sys"
 version = "0.1.4"
@@ -2246,6 +2379,18 @@ version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"

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

+[[package]]
+name = "mysql"
+version = "27.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "090068bc0a24762663338da78414148333d1ee246a7293c10a517ddf1548b291"
+dependencies = [
+ "bufstream",
+ "bytes",
+ "crossbeam-queue",
+ "crossbeam-utils",
+ "flate2",
+ "io-enum",
+ "libc",
+ "lru",
+ "mysql_common",
+ "named_pipe",
+ "pem",
+ "percent-encoding",
+ "rustls",
+ "rustls-pemfile",
+ "socket2 0.6.5",
+ "twox-hash",
+ "url",
+ "webpki",
+ "webpki-roots 1.0.10",
+]
+
+[[package]]
+name = "mysql_common"
+version = "0.36.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20e7f6a15265801679ddf1ddb38fd74b4555a677a78378d4561fbe5f0b1d4d72"
+dependencies = [
+ "base64",
+ "bitflags 2.13.2",
+ "btoi",
+ "byteorder",
+ "bytes",
+ "chrono",
+ "crc32fast",
+ "flate2",
+ "getrandom 0.3.4",
+ "num-bigint",
+ "num-traits",
+ "regex",
+ "saturating",
+ "serde",
+ "serde_json",
+ "sha1",
+ "sha2",
+ "thiserror 2.0.21",
+ "uuid",
+]
+
 [[package]]
 name = "naga"
 version = "30.0.1"
@@ -2354,7 +2553,7 @@ dependencies = [
 "num-traits",
 "once_cell",
 "pp-rs",
- "rustc-hash",
+ "rustc-hash 1.1.0",
 "spirv",
 "thiserror 2.0.21",
 "unicode-ident",
@@ -2368,10 +2567,19 @@ checksum = "590afbf58a6f4f62873cd5cff4468061844bafa1cdf399cc954537c22d768d49"
 dependencies = [
 "hashbrown 0.17.1",
 "indexmap",
- "rustc-hash",
+ "rustc-hash 1.1.0",
 "thiserror 2.0.21",
 ]

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

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

+[[package]]
+name = "quinn"
+version = "0.11.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4051e23e9185c255a7e33ef59cdbca87a22d359052eecd22fc6b901fb37d9d11"
+dependencies = [
+ "bytes",
+ "cfg_aliases",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash 2.1.3",
+ "rustls",
+ "socket2 0.6.5",
+ "thiserror 2.0.21",
+ "tokio",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-proto"
+version = "0.11.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e750cca55fe4f0439a15d0bb529da9651e79993e8e72c61a899a36d462befbe"
+dependencies = [
+ "bytes",
+ "getrandom 0.4.3",
+ "lru-slab",
+ "rand",
+ "rand_pcg",
+ "ring",
+ "rustc-hash 2.1.3",
+ "rustls",
+ "rustls-pki-types",
+ "slab",
+ "thiserror 2.0.21",
+ "tinyvec",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-udp"
+version = "0.5.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af66907df18639dcf4db56ca65490cabc4b27a97dbadd96f2926cca73298f016"
+dependencies = [
+ "cfg_aliases",
+ "libc",
+ "once_cell",
+ "socket2 0.6.5",
+ "tracing",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.47"
@@ -3252,6 +3526,15 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"

+[[package]]
+name = "rand_pcg"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a"
+dependencies = [
+ "rand_core 0.10.1",
+]
+
 [[package]]
 name = "range-alloc"
 version = "0.1.5"
@@ -3298,6 +3581,22 @@ dependencies = [
 "yasna",
 ]

+[[package]]
+name = "redis"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db7f3d75b5a3301746bff39a767bf4c5c42506b08513527308b3875bfb64a031"
+dependencies = [
+ "arcstr",
+ "combine",
+ "itoa",
+ "percent-encoding",
+ "ryu",
+ "socket2 0.6.5",
+ "url",
+ "xxhash-rust",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.4.1"
@@ -3374,12 +3673,32 @@ dependencies = [
 "windows-sys 0.52.0",
 ]

+[[package]]
+name = "rusqlite"
+version = "0.41.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da9bba6f3506135e120a6586df05be18b48d18896600646a4bec8f993d91a594"
+dependencies = [
+ "bitflags 2.13.2",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "smallvec",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"

+[[package]]
+name = "rustc-hash"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
+
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -3439,12 +3758,22 @@ dependencies = [
 "zeroize",
 ]

+[[package]]
+name = "rustls-pemfile"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
+dependencies = [
+ "rustls-pki-types",
+]
+
 [[package]]
 name = "rustls-pki-types"
 version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
 dependencies = [
+ "web-time",
 "zeroize",
 ]

@@ -3465,6 +3794,12 @@ version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"

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

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

+[[package]]
+name = "saturating"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ece8e78b2f38ec51c51f5d475df0a7187ba5111b2a28bdc761ee05b075d40a71"
+
 [[package]]
 name = "scoped-tls"
 version = "1.0.1"
@@ -3691,6 +4038,12 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "snap"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "199905e6153d6405f9728fe44daace35f8f837bbf830bb6e85fbd5828709a886"
+
 [[package]]
 name = "socket2"
 version = "0.5.10"
@@ -3711,6 +4064,17 @@ dependencies = [
 "windows-sys 0.61.2",
 ]

+[[package]]
+name = "socks"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0c3dbbd9ae980613c6dd8e28a9407b50509d3803b57624d5dfe8315218cd58b"
+dependencies = [
+ "byteorder",
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "spake2"
 version = "0.4.0"
@@ -3995,13 +4359,23 @@ dependencies = [
 "zerovec",
 ]

+[[package]]
+name = "tinyvec"
+version = "1.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd3ca314f692efd6c868f8408f53fe444634a845f96c028b97d35f6a1f79f0ee"
+
 [[package]]
 name = "tokio"
 version = "1.53.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e95f91fcc7a621e8b030f6aa23c71fe9838ae2fb4d8118b75602a328f5144044"
 dependencies = [
+ "libc",
+ "mio",
 "pin-project-lite",
+ "socket2 0.6.5",
+ "windows-sys 0.61.2",
 ]

 [[package]]
@@ -4071,6 +4445,9 @@ name = "tracing-core"
 version = "0.1.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]

 [[package]]
 name = "tree_magic_mini"
@@ -4089,6 +4466,18 @@ version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"

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

+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
 [[package]]
 name = "vec_map"
 version = "0.8.2"
@@ -4431,6 +4827,16 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "webpki"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
 [[package]]
 name = "webpki-roots"
 version = "0.26.11"
@@ -4449,6 +4855,12 @@ dependencies = [
 "rustls-pki-types",
 ]

+[[package]]
+name = "weezl"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
+
 [[package]]
 name = "wgpu"
 version = "30.0.1"
@@ -4502,7 +4914,7 @@ dependencies = [
 "portable-atomic",
 "profiling",
 "raw-window-handle",
- "rustc-hash",
+ "rustc-hash 1.1.0",
 "smallvec",
 "thiserror 2.0.21",
 "wgpu-core-deps-apple",
@@ -4626,6 +5038,22 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"

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

+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
 [[package]]
 name = "windows"
 version = "0.54.0"
@@ -5223,6 +5657,16 @@ version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "550a2b930b62486a393c52d5c3b84bff264b28aa437ed64694d31e93b1757af7"

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

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

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

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

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

 ## What works today

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

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

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

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

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

 ## Agent control

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

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

 ## Build from source

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

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

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

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

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

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

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

 ### Java parity: 100%

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

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

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

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

 <details><summary>Technical</summary>

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

 </details>

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

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

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

 </details>

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

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

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

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

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

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

 </details>

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

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

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

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

 ### Servers and multiplayer

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

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

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

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

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

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

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

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

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

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

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

 </details>

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

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

 </details>

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

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

 </details>

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

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

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

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

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

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

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

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

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

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

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

 </details>

-### Gameplay parity
-
-#### End city banners keep their pattern
-
-Banners in End cities show as plain magenta instead of with their pattern.
-
-<details><summary>Technical</summary>
-
-Compare the banner block entities the End city templates place with vanilla's (`EndCityPieces`, the templates' block entity NBT, `BannerBlockEntity`'s patterns), in `crates/horizon-world/src/worldgen/structure/`. Issue [#1438](https://github.com/horizon-rust/horizon/issues/1438); possibly related: [#526](https://github.com/horizon-rust/horizon/issues/526).
-
-</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).
-
-</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)
@@ -16,6 +16,8 @@ are in that folder (`LICENSE.MIT`, `LICENSE.APACHE`).

 The GLSL frontend also resets the common type for each comma-separated declarator so one
 variable's array specifier does not change later variables.
+It also reads a struct member outside a constant expression through a pointer to the member,
+not out of a loaded copy of the whole struct, so a member an atomic function uses can be read.

 ## libmimalloc-sys and mimalloc

@@ -168,3 +170,45 @@ BlueMap is licensed under the MIT license:
 > LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 > OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 > THE SOFTWARE.
+
+## JOML
+
+`crates/horizon-client-render/src/camera.rs` (`joml::Mat4::rotation`, `invert_orthonormal`) and
+`crates/horizon-client-render/src/gfx/pack_uniforms.rs` (`invert_generic`, `invert_affine`, the
+formulas of `pack_projection` and `shadow_ortho`) adapt the float arithmetic of
+`Matrix4f.rotation(Quaternionfc)`, `invertOrthonormal`, `invertGenericNonThis`, `invertAffine`,
+`setPerspective` and `setOrtho` from
+[JOML](https://github.com/JOML-CI/JOML/tree/faf9eef2511242122beb6055fe3da92daed214c5) 1.10.9, the
+library vanilla 26.3 uses, so that shader packs get the same matrices to the last bit. Changes:
+ported to Rust; the pack_uniforms.rs functions drop JOML's property flags, and
+`pack_projection` works the formula in doubles. The copyright line and license notice also head
+both files.
+
+`camera.rs` also adapts `Quaternionf.rotationX`, `rotationY` and `rotationZ`,
+`Matrix4f.rotateAffine` and `Vector4f.mulAffine` (`joml::Quat::rotation_x`/`_y`/`_z`,
+`joml::Mat4::rotate_affine`, `transform_affine`), for the sky's positions shader packs read.
+Changes: ported to Rust; `rotate_affine` keeps only the affine case.
+
+```
+The MIT License
+
+Copyright (c) 2015-2026 Richard Greenlees
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+```
@@ -0,0 +1,42 @@
+# Entity occlusion split measurements — 2026-11-02
+
+These measurements came from the pre-split integration branch for PR #7054. That build contained the entity-occlusion rewrite and particle light lookup cache; Particle Culling was Off. They are useful comparison evidence, but they are not a benchmark of this isolated entity-only commit. The cache-only run in PR #7391 measured effectively the same CPU time on the ordinary scene, but the combined result still cannot isolate interactions.
+
+Host: Intel Core i7-3770S, Intel HD Graphics 4000, Vulkan/Mesa, 675×727, render distance 4, VSync off, 260 FPS cap. Two opposite-order passes measured for 8 seconds after warmup. Values are means. CPU is harness average CPU ms per frame; p99 is frame time. The driver supplied no usable GPU timing.
+
+## Ordinary scene
+
+The scene had 24 mobs, roughly 9,400–10,100 rain particles and campfire smoke.
+
+| Build and mode | FPS | CPU ms/frame | Frame p99 ms |
+| --- | ---: | ---: | ---: |
+| Main, entity culling Off | 88.59 | 1.829 | 24.51 |
+| Pre-split integration branch, all culling Off | 88.33 | 2.063 | 24.51 |
+| Main, entity culling Synchronous | 89.34 | 1.965 | 23.99 |
+| Pre-split integration branch, entity Synchronous | 89.13 | 2.113 | 24.15 |
+
+This normal-scene run does not show a large FPS change; its CPU differences are small relative to frame time and not attributable to the entity-only change by themselves.
+
+## Opaque-wall scene
+
+A 32×32 platform at Y=300, a 7-block wall with a one-block vertical opening, and 192 pigs spawned behind the wall (216 mobs in the captured scene). The player looked toward the opening from the near side. The same world and camera path were used for the main and integration builds.
+
+| Build and mode | FPS | CPU ms/frame | Frame p99 ms |
+| --- | ---: | ---: | ---: |
+| Main, Off | 89.08 | 2.423 | 13.52 |
+| Integration branch, Off | 89.23 | 2.355 | 13.27 |
+| Main, Synchronous | 92.81 | 2.566 | 14.60 |
+| Integration branch, Synchronous | 93.21 | 2.550 | 12.84 |
+| Main, Asynchronous | 92.73 | 2.364 | 13.04 |
+| Integration branch, Asynchronous | 92.62 | 2.314 | 13.18 |
+
+The asynchronous mode reduced measured CPU time slightly in this wall scene but did not improve FPS beyond run-to-run spread. This is a synthetic occlusion-heavy scene, not a broad performance claim.
+
+## Captures
+
+The HUD performance overlay is visible in each capture. The integration-build screenshots were recorded with the same wall and camera position in Off, Synchronous, and Asynchronous modes.
+
+- Main, Off: `main-off.png`
+- Integration branch, Off: `branch-off.png`
+- Integration branch, Synchronous: `branch-sync.png`
+- Integration branch, Asynchronous: `branch-async.png`
@@ -0,0 +1,42 @@
+# Entity occlusion pipeline — release/OpenGL run (2026-11-04)
+
+This is the final local smoke benchmark for the entity-occlusion pipeline before opening the PR. It was run from the branch after the release build completed, with the OpenGL backend selected explicitly. The same process created each scene, switched the culling mode, flew the camera for two seconds, collected frame/CPU telemetry, and captured the screenshot after the scene settled.
+
+**Host:** Intel Core i7-3770S, Intel HD Graphics 4000, Mesa OpenGL 4.2
+**Window:** 1280×720, offscreen, VSync disabled
+**World:** fresh temporary home, 32×32 platform at Y=300; wall scenes add a solid stone wall and an optional one-block slit
+**Entities:** 24 pigs in the normal scene, 192 pigs in wall scenes, 512 pigs in stress scenes
+**Settings:** render distance 8, `entityCullingPrecheck:64`, FPS overlay on, no resource-pack occlusion assumptions
+**Build:** `cargo build --release -p horizon-client`
+
+## Results
+
+The values below are branch-only measurements. They are useful for comparing the three modes under identical geometry and for checking that the worker is doing useful work. A fresh main binary was not built in this short pass, so these numbers do not claim a controlled main-to-branch delta.
+
+| Scene | Off FPS / CPU p50 | Sync FPS / CPU p50 | Async FPS / CPU p50 | Async entities culled |
+| --- | ---: | ---: | ---: | ---: |
+| `entity_normal` (24 visible) | 240.5 / 0.586 ms | 233.5 / 0.762 ms | 239.3 / 0.686 ms | 0 |
+| `entity_wall` (192, solid) | 228.8 / 1.245 ms | 318.6 / 1.342 ms | **324.5 / 0.478 ms** | 124,608 |
+| `entity_wall_slit` (192, one-block slit) | 231.4 / 1.102 ms | 265.0 / 1.387 ms | **281.2 / 0.716 ms** | 102,826 |
+| `entity_stress` (512, solid) | 190.3 / 2.467 ms | 299.2 / 2.593 ms | **325.5 / 0.691 ms** | 290,234 |
+| `entity_stress_slit` (512, one-block slit) | 190.4 / 2.476 ms | 262.2 / 2.573 ms | **262.1 / 1.297 ms** | 227,301 |
+
+Async telemetry confirmed that the render thread stayed non-blocking (`try_recv`/`try_send`, `worker_blocking_wait_ms: 0`). The latest wall/slit run completed 562 worker jobs, queued 3,982 queries, avoided about 4.0 million entity bytes, and had 379 ns recent p50 worker-job time. The solid 512-pig run culled 15,552 generated vertices; the slit run culled 120,290 generated vertices. The normal scene recorded no pre-model hides and kept the opt-in path close to Off.
+
+## Captures
+
+Every image includes the FPS performance overlay. The names are `<mode>-<scene>.png`:
+
+- [Off — normal](screenshots/off-entity_normal.png), [wall](screenshots/off-entity_wall.png), [wall slit](screenshots/off-entity_wall_slit.png), [stress](screenshots/off-entity_stress.png), [stress slit](screenshots/off-entity_stress_slit.png)
+- [Sync — normal](screenshots/sync-entity_normal.png), [wall](screenshots/sync-entity_wall.png), [wall slit](screenshots/sync-entity_wall_slit.png), [stress](screenshots/sync-entity_stress.png), [stress slit](screenshots/sync-entity_stress_slit.png)
+- [Async — normal](screenshots/async-entity_normal.png), [wall](screenshots/async-entity_wall.png), [wall slit](screenshots/async-entity_wall_slit.png), [stress](screenshots/async-entity_stress.png), [stress slit](screenshots/async-entity_stress_slit.png)
+
+## Reproduction
+
+From the repository root, with prepared 26.3 resources available:
+
+```sh
+python3 tools/entity_occlusion_bench.py
+```
+
+The script uses fresh temporary game data, the release binary in `target/release`, OpenGL, the FPS overlay, and writes JSON plus captures under `/tmp/horizon-entity-occlusion-release-quick/`.
@@ -0,0 +1,870 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-11-04T13:00:15Z",
+ "app": {
+  "name": "horizon-client",
+  "version": "nightly-2026-11-04-67dad0d",
+  "commit": "67dad0d"
+ },
+ "hardware": {
+  "os": "linux",
+  "arch": "x86_64",
+  "cpu_threads": 24,
+  "os_version": "NixOS 26.05 (Yarara) (kernel 6.18.57)",
+  "cpu": "13th Gen Intel(R) Core(TM) i7-13700KF",
+  "ram_mb": 31904,
+  "gpu": {
+   "name": "NVIDIA GeForce RTX 4080",
+   "vendor": "nvidia",
+   "driver": "NVIDIA 595.71.05",
+   "backend": "vulkan",
+   "kind": "discrete"
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 12,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "load_avg_1m": 28.408,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 66658.183,
+   "stdev": 61839.502,
+   "min": 1827.42,
+   "max": 124993.694,
+   "ci95": 153630.237
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 74754.411,
+   "stdev": 59189.587,
+   "min": 13600.651,
+   "max": 131761.773,
+   "ci95": 147046.952
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 5571.499,
+   "stdev": 1900.32,
+   "min": 3378.38,
+   "max": 6730.394,
+   "ci95": 4721.037
+  },
+  "chunks.village.meshed_count": {
+   "n": 3,
+   "mean": 15287.0,
+   "stdev": 527.501,
+   "min": 14788.0,
+   "max": 15839.0,
+   "ci95": 1310.49
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 2958.557,
+   "stdev": 376.543,
+   "min": 2526.453,
+   "max": 3216.434,
+   "ci95": 935.46
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 368.457,
+   "stdev": 90.668,
+   "min": 300.631,
+   "max": 471.438,
+   "ci95": 225.25
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 91.04,
+   "stdev": 40.506,
+   "min": 46.124,
+   "max": 124.796,
+   "ci95": 100.63
+  },
+  "memory.village.gpu_mb": {
+   "n": 3,
+   "mean": 581.0,
+   "stdev": 48.0,
+   "min": 533.0,
+   "max": 629.0,
+   "ci95": 119.248
+  },
+  "memory.village.rss_mb": {
+   "n": 3,
+   "mean": 1277.531,
+   "stdev": 25.546,
+   "min": 1253.879,
+   "max": 1304.623,
+   "ci95": 63.466
+  },
+  "tick.village.client_ms": {
+   "n": 3,
+   "mean": 0.529,
+   "stdev": 0.127,
+   "min": 0.396,
+   "max": 0.649,
+   "ci95": 0.315
+  },
+  "cpu.village.p50_ms": {
+   "n": 3,
+   "mean": 0.185,
+   "stdev": 0.034,
+   "min": 0.162,
+   "max": 0.224,
+   "ci95": 0.085
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 3318.3,
+   "stdev": 911.608,
+   "min": 2266.627,
+   "max": 3883.075,
+   "ci95": 2264.743
+  },
+  "chunks.forest.meshed_count": {
+   "n": 3,
+   "mean": 16565.333,
+   "stdev": 172.755,
+   "min": 16367.0,
+   "max": 16683.0,
+   "ci95": 429.182
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 2333.626,
+   "stdev": 569.124,
+   "min": 1745.365,
+   "max": 2881.457,
+   "ci95": 1413.897
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 336.615,
+   "stdev": 185.666,
+   "min": 208.133,
+   "max": 549.487,
+   "ci95": 461.257
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 160.734,
+   "stdev": 127.586,
+   "min": 39.777,
+   "max": 294.05,
+   "ci95": 316.967
+  },
+  "memory.forest.gpu_mb": {
+   "n": 3,
+   "mean": 666.333,
+   "stdev": 24.44,
+   "min": 645.0,
+   "max": 693.0,
+   "ci95": 60.718
+  },
+  "memory.forest.rss_mb": {
+   "n": 3,
+   "mean": 1346.816,
+   "stdev": 42.279,
+   "min": 1305.547,
+   "max": 1390.037,
+   "ci95": 105.035
+  },
+  "tick.forest.client_ms": {
+   "n": 3,
+   "mean": 0.669,
+   "stdev": 0.084,
+   "min": 0.598,
+   "max": 0.761,
+   "ci95": 0.208
+  },
+  "cpu.forest.p50_ms": {
+   "n": 3,
+   "mean": 0.222,
+   "stdev": 0.032,
+   "min": 0.197,
+   "max": 0.258,
+   "ci95": 0.079
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 2463.434,
+   "stdev": 1056.0,
+   "min": 1527.516,
+   "max": 3608.283,
+   "ci95": 2623.462
+  },
+  "chunks.ocean.meshed_count": {
+   "n": 3,
+   "mean": 14226.667,
+   "stdev": 307.077,
+   "min": 14038.0,
+   "max": 14581.0,
+   "ci95": 762.883
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 2192.874,
+   "stdev": 1320.904,
+   "min": 673.829,
+   "max": 3071.415,
+   "ci95": 3281.573
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 345.406,
+   "stdev": 294.904,
+   "min": 8.977,
+   "max": 559.232,
+   "ci95": 732.642
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 172.573,
+   "stdev": 149.386,
+   "min": 1.038,
+   "max": 274.089,
+   "ci95": 371.125
+  },
+  "memory.ocean.gpu_mb": {
+   "n": 3,
+   "mean": 629.0,
+   "stdev": 32.0,
+   "min": 597.0,
+   "max": 661.0,
+   "ci95": 79.499
+  },
+  "memory.ocean.rss_mb": {
+   "n": 3,
+   "mean": 1352.223,
+   "stdev": 51.951,
+   "min": 1301.492,
+   "max": 1405.314,
+   "ci95": 129.065
+  },
+  "tick.ocean.client_ms": {
+   "n": 3,
+   "mean": 0.512,
+   "stdev": 0.099,
+   "min": 0.406,
+   "max": 0.603,
+   "ci95": 0.246
+  },
+  "cpu.ocean.p50_ms": {
+   "n": 3,
+   "mean": 0.178,
+   "stdev": 0.038,
+   "min": 0.135,
+   "max": 0.206,
+   "ci95": 0.094
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 6260.675,
+   "stdev": 3077.348,
+   "min": 2976.342,
+   "max": 9077.55,
+   "ci95": 7645.173
+  },
+  "chunks.mountain.meshed_count": {
+   "n": 3,
+   "mean": 16015.333,
+   "stdev": 209.872,
+   "min": 15826.0,
+   "max": 16241.0,
+   "ci95": 521.393
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 1412.095,
+   "stdev": 962.145,
+   "min": 714.773,
+   "max": 2509.775,
+   "ci95": 2390.293
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 182.479,
+   "stdev": 177.563,
+   "min": 13.364,
+   "max": 367.429,
+   "ci95": 441.126
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 88.451,
+   "stdev": 87.578,
+   "min": 1.526,
+   "max": 176.667,
+   "ci95": 217.572
+  },
+  "memory.mountain.gpu_mb": {
+   "n": 3,
+   "mean": 799.667,
+   "stdev": 18.475,
+   "min": 789.0,
+   "max": 821.0,
+   "ci95": 45.899
+  },
+  "memory.mountain.rss_mb": {
+   "n": 3,
+   "mean": 1491.572,
+   "stdev": 36.719,
+   "min": 1459.775,
+   "max": 1531.76,
+   "ci95": 91.221
+  },
+  "tick.mountain.client_ms": {
+   "n": 3,
+   "mean": 0.697,
+   "stdev": 0.155,
+   "min": 0.602,
+   "max": 0.876,
+   "ci95": 0.386
+  },
+  "cpu.mountain.p50_ms": {
+   "n": 3,
+   "mean": 0.325,
+   "stdev": 0.115,
+   "min": 0.239,
+   "max": 0.456,
+   "ci95": 0.286
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 1545.896,
+   "stdev": 30.591,
+   "min": 1524.965,
+   "max": 1581.004,
+   "ci95": 75.999
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 1348.389,
+   "stdev": 52.5,
+   "min": 1296.172,
+   "max": 1401.168,
+   "ci95": 130.428
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 37594,
+   "seconds": 12.0,
+   "avg_fps": 3132.783,
+   "low_1pct_fps": 471.438,
+   "low_01pct_fps": 124.796,
+   "p50_ms": 0.271,
+   "p95_ms": 0.494,
+   "p99_ms": 1.127,
+   "p999_ms": 2.15,
+   "max_ms": 155.204,
+   "cpu_p50_ms": 0.168,
+   "gpu_p50_ms": 0.104,
+   "histogram": [
+    37151,
+    394,
+    30,
+    8,
+    5,
+    2,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 38598,
+   "seconds": 12.0,
+   "avg_fps": 3216.434,
+   "low_1pct_fps": 300.631,
+   "low_01pct_fps": 46.124,
+   "p50_ms": 0.267,
+   "p95_ms": 0.446,
+   "p99_ms": 1.034,
+   "p999_ms": 1.941,
+   "max_ms": 493.993,
+   "cpu_p50_ms": 0.162,
+   "gpu_p50_ms": 0.104,
+   "histogram": [
+    38177,
+    387,
+    16,
+    8,
+    4,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 30318,
+   "seconds": 12.0,
+   "avg_fps": 2526.453,
+   "low_1pct_fps": 333.302,
+   "low_01pct_fps": 102.199,
+   "p50_ms": 0.305,
+   "p95_ms": 0.757,
+   "p99_ms": 1.69,
+   "p999_ms": 3.539,
+   "max_ms": 170.856,
+   "cpu_p50_ms": 0.224,
+   "gpu_p50_ms": 0.106,
+   "histogram": [
+    29368,
+    759,
+    139,
+    35,
+    11,
+    3,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 34578,
+   "seconds": 12.0,
+   "avg_fps": 2881.457,
+   "low_1pct_fps": 549.487,
+   "low_01pct_fps": 294.05,
+   "p50_ms": 0.32,
+   "p95_ms": 0.483,
+   "p99_ms": 1.213,
+   "p999_ms": 2.5,
+   "max_ms": 5.358,
+   "cpu_p50_ms": 0.197,
+   "gpu_p50_ms": 0.154,
+   "histogram": [
+    34119,
+    379,
+    64,
+    9,
+    5,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 28489,
+   "seconds": 12.0,
+   "avg_fps": 2374.055,
+   "low_1pct_fps": 208.133,
+   "low_01pct_fps": 39.777,
+   "p50_ms": 0.313,
+   "p95_ms": 0.937,
+   "p99_ms": 1.863,
+   "p999_ms": 4.318,
+   "max_ms": 571.48,
+   "cpu_p50_ms": 0.211,
+   "gpu_p50_ms": 0.151,
+   "histogram": [
+    27193,
+    1071,
+    140,
+    51,
+    19,
+    9,
+    1,
+    2,
+    1,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 20945,
+   "seconds": 12.0,
+   "avg_fps": 1745.365,
+   "low_1pct_fps": 252.226,
+   "low_01pct_fps": 148.375,
+   "p50_ms": 0.343,
+   "p95_ms": 1.505,
+   "p99_ms": 2.758,
+   "p999_ms": 5.341,
+   "max_ms": 11.642,
+   "cpu_p50_ms": 0.258,
+   "gpu_p50_ms": 0.162,
+   "histogram": [
+    18145,
+    2293,
+    337,
+    106,
+    38,
+    13,
+    6,
+    5,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 36856,
+   "seconds": 12.0,
+   "avg_fps": 3071.415,
+   "low_1pct_fps": 559.232,
+   "low_01pct_fps": 274.089,
+   "p50_ms": 0.286,
+   "p95_ms": 0.492,
+   "p99_ms": 1.179,
+   "p999_ms": 2.711,
+   "max_ms": 6.718,
+   "cpu_p50_ms": 0.135,
+   "gpu_p50_ms": 0.127,
+   "histogram": [
+    36366,
+    405,
+    60,
+    13,
+    10,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 34001,
+   "seconds": 12.0,
+   "avg_fps": 2833.377,
+   "low_1pct_fps": 468.008,
+   "low_01pct_fps": 242.591,
+   "p50_ms": 0.295,
+   "p95_ms": 0.589,
+   "p99_ms": 1.41,
+   "p999_ms": 3.048,
+   "max_ms": 7.7,
+   "cpu_p50_ms": 0.206,
+   "gpu_p50_ms": 0.126,
+   "histogram": [
+    33314,
+    544,
+    106,
+    23,
+    10,
+    2,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 8086,
+   "seconds": 12.0,
+   "avg_fps": 673.829,
+   "low_1pct_fps": 8.977,
+   "low_01pct_fps": 1.038,
+   "p50_ms": 0.302,
+   "p95_ms": 0.665,
+   "p99_ms": 2.495,
+   "p999_ms": 15.716,
+   "max_ms": 4849.364,
+   "cpu_p50_ms": 0.194,
+   "gpu_p50_ms": 0.128,
+   "histogram": [
+    7808,
+    166,
+    50,
+    26,
+    8,
+    2,
+    3,
+    5,
+    2,
+    5,
+    1,
+    2,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    2
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 12141,
+   "seconds": 12.0,
+   "avg_fps": 1011.738,
+   "low_1pct_fps": 166.643,
+   "low_01pct_fps": 87.16,
+   "p50_ms": 0.641,
+   "p95_ms": 2.642,
+   "p99_ms": 4.468,
+   "p999_ms": 7.821,
+   "max_ms": 22.536,
+   "cpu_p50_ms": 0.456,
+   "gpu_p50_ms": 0.138,
+   "histogram": [
+    7840,
+    2996,
+    866,
+    278,
+    87,
+    38,
+    16,
+    11,
+    2,
+    5,
+    0,
+    0,
+    0,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 30118,
+   "seconds": 12.0,
+   "avg_fps": 2509.775,
+   "low_1pct_fps": 367.429,
+   "low_01pct_fps": 176.667,
+   "p50_ms": 0.316,
+   "p95_ms": 0.771,
+   "p99_ms": 1.931,
+   "p999_ms": 4.2,
+   "max_ms": 14.633,
+   "cpu_p50_ms": 0.239,
+   "gpu_p50_ms": 0.127,
+   "histogram": [
+    29101,
+    775,
+    173,
+    38,
+    16,
+    8,
+    4,
+    1,
+    0,
+    1,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 8577,
+   "seconds": 12.0,
+   "avg_fps": 714.773,
+   "low_1pct_fps": 13.364,
+   "low_01pct_fps": 1.526,
+   "p50_ms": 0.416,
+   "p95_ms": 2.257,
+   "p99_ms": 4.36,
+   "p999_ms": 212.217,
+   "max_ms": 1051.428,
+   "cpu_p50_ms": 0.28,
+   "gpu_p50_ms": 0.132,
+   "histogram": [
+    7017,
+    978,
+    377,
+    111,
+    39,
+    24,
+    10,
+    6,
+    1,
+    0,
+    2,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    1,
+    2,
+    4,
+    2
+   ]
+  }
+ ],
+ "label": "horizon-desktop"
+}
@@ -0,0 +1,870 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-11-04T14:47:19Z",
+ "app": {
+  "name": "horizon-client",
+  "version": "nightly-2026-11-04-67dad0d",
+  "commit": "67dad0d"
+ },
+ "hardware": {
+  "os": "linux",
+  "arch": "x86_64",
+  "cpu_threads": 24,
+  "os_version": "NixOS 26.05 (Yarara) (kernel 6.18.57)",
+  "cpu": "13th Gen Intel(R) Core(TM) i7-13700KF",
+  "ram_mb": 31904,
+  "gpu": {
+   "name": "NVIDIA GeForce RTX 4080",
+   "vendor": "nvidia",
+   "driver": "NVIDIA 595.71.05",
+   "backend": "vulkan",
+   "kind": "discrete"
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 32,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "load_avg_1m": 29.665,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 45386.16,
+   "stdev": 38970.921,
+   "min": 1077.276,
+   "max": 74343.156,
+   "ci95": 96816.948
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 86585.608,
+   "stdev": 71331.593,
+   "min": 11201.581,
+   "max": 153020.143,
+   "ci95": 177211.803
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 11082.587,
+   "stdev": 5351.291,
+   "min": 7620.454,
+   "max": 17246.096,
+   "ci95": 13294.417
+  },
+  "chunks.village.meshed_count": {
+   "n": 3,
+   "mean": 48440.333,
+   "stdev": 656.16,
+   "min": 48060.0,
+   "max": 49198.0,
+   "ci95": 1630.124
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 853.775,
+   "stdev": 345.646,
+   "min": 524.913,
+   "max": 1214.059,
+   "ci95": 858.701
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 130.235,
+   "stdev": 117.39,
+   "min": 9.024,
+   "max": 243.388,
+   "ci95": 291.635
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 70.65,
+   "stdev": 68.628,
+   "min": 1.125,
+   "max": 138.345,
+   "ci95": 170.496
+  },
+  "memory.village.gpu_mb": {
+   "n": 3,
+   "mean": 2202.333,
+   "stdev": 33.307,
+   "min": 2165.0,
+   "max": 2229.0,
+   "ci95": 82.745
+  },
+  "memory.village.rss_mb": {
+   "n": 3,
+   "mean": 1652.647,
+   "stdev": 73.452,
+   "min": 1568.063,
+   "max": 1700.344,
+   "ci95": 182.478
+  },
+  "tick.village.client_ms": {
+   "n": 3,
+   "mean": 0.493,
+   "stdev": 0.169,
+   "min": 0.319,
+   "max": 0.657,
+   "ci95": 0.42
+  },
+  "cpu.village.p50_ms": {
+   "n": 3,
+   "mean": 0.692,
+   "stdev": 0.207,
+   "min": 0.531,
+   "max": 0.925,
+   "ci95": 0.513
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 15019.921,
+   "stdev": 12855.4,
+   "min": 5613.942,
+   "max": 29668.11,
+   "ci95": 31937.162
+  },
+  "chunks.forest.meshed_count": {
+   "n": 3,
+   "mean": 80224.667,
+   "stdev": 678.709,
+   "min": 79626.0,
+   "max": 80962.0,
+   "ci95": 1686.142
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 898.208,
+   "stdev": 446.3,
+   "min": 382.944,
+   "max": 1163.61,
+   "ci95": 1108.759
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 178.513,
+   "stdev": 107.096,
+   "min": 54.933,
+   "max": 244.255,
+   "ci95": 266.064
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 103.369,
+   "stdev": 78.403,
+   "min": 12.974,
+   "max": 152.87,
+   "ci95": 194.779
+  },
+  "memory.forest.gpu_mb": {
+   "n": 3,
+   "mean": 2201.667,
+   "stdev": 34.429,
+   "min": 2163.0,
+   "max": 2229.0,
+   "ci95": 85.532
+  },
+  "memory.forest.rss_mb": {
+   "n": 3,
+   "mean": 1809.063,
+   "stdev": 93.103,
+   "min": 1707.98,
+   "max": 1891.305,
+   "ci95": 231.3
+  },
+  "tick.forest.client_ms": {
+   "n": 3,
+   "mean": 0.585,
+   "stdev": 0.147,
+   "min": 0.493,
+   "max": 0.754,
+   "ci95": 0.365
+  },
+  "cpu.forest.p50_ms": {
+   "n": 3,
+   "mean": 0.989,
+   "stdev": 0.725,
+   "min": 0.57,
+   "max": 1.826,
+   "ci95": 1.802
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 12399.047,
+   "stdev": 15052.073,
+   "min": 3174.115,
+   "max": 29768.486,
+   "ci95": 37394.441
+  },
+  "chunks.ocean.meshed_count": {
+   "n": 3,
+   "mean": 64737.0,
+   "stdev": 16149.666,
+   "min": 46089.0,
+   "max": 74089.0,
+   "ci95": 40121.232
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 735.22,
+   "stdev": 601.75,
+   "min": 108.108,
+   "max": 1307.912,
+   "ci95": 1494.952
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 134.654,
+   "stdev": 147.391,
+   "min": 1.252,
+   "max": 292.881,
+   "ci95": 366.169
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 62.062,
+   "stdev": 66.294,
+   "min": 0.202,
+   "max": 132.042,
+   "ci95": 164.697
+  },
+  "memory.ocean.gpu_mb": {
+   "n": 3,
+   "mean": 1942.333,
+   "stdev": 251.725,
+   "min": 1657.0,
+   "max": 2133.0,
+   "ci95": 625.369
+  },
+  "memory.ocean.rss_mb": {
+   "n": 3,
+   "mean": 1812.661,
+   "stdev": 102.065,
+   "min": 1697.912,
+   "max": 1893.313,
+   "ci95": 253.564
+  },
+  "tick.ocean.client_ms": {
+   "n": 3,
+   "mean": 0.421,
+   "stdev": 0.227,
+   "min": 0.193,
+   "max": 0.646,
+   "ci95": 0.563
+  },
+  "cpu.ocean.p50_ms": {
+   "n": 3,
+   "mean": 0.513,
+   "stdev": 0.194,
+   "min": 0.303,
+   "max": 0.686,
+   "ci95": 0.483
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 31815.539,
+   "stdev": 36758.245,
+   "min": 9582.166,
+   "max": 74243.988,
+   "ci95": 91319.913
+  },
+  "chunks.mountain.meshed_count": {
+   "n": 3,
+   "mean": 90876.333,
+   "stdev": 1525.588,
+   "min": 89793.0,
+   "max": 92621.0,
+   "ci95": 3790.075
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 712.657,
+   "stdev": 252.815,
+   "min": 450.565,
+   "max": 955.041,
+   "ci95": 628.077
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 117.93,
+   "stdev": 85.922,
+   "min": 24.389,
+   "max": 193.34,
+   "ci95": 213.46
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 72.407,
+   "stdev": 65.468,
+   "min": 3.577,
+   "max": 133.895,
+   "ci95": 162.646
+  },
+  "memory.mountain.gpu_mb": {
+   "n": 3,
+   "mean": 2783.667,
+   "stdev": 48.881,
+   "min": 2741.0,
+   "max": 2837.0,
+   "ci95": 121.436
+  },
+  "memory.mountain.rss_mb": {
+   "n": 3,
+   "mean": 1931.359,
+   "stdev": 106.681,
+   "min": 1808.184,
+   "max": 1994.242,
+   "ci95": 265.031
+  },
+  "tick.mountain.client_ms": {
+   "n": 3,
+   "mean": 1.03,
+   "stdev": 0.685,
+   "min": 0.564,
+   "max": 1.817,
+   "ci95": 1.702
+  },
+  "cpu.mountain.p50_ms": {
+   "n": 3,
+   "mean": 1.025,
+   "stdev": 0.315,
+   "min": 0.765,
+   "max": 1.376,
+   "ci95": 0.783
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 2051.333,
+   "stdev": 147.151,
+   "min": 1884.176,
+   "max": 2161.316,
+   "ci95": 365.573
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 1810.92,
+   "stdev": 94.623,
+   "min": 1707.342,
+   "max": 1892.828,
+   "ci95": 235.075
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 6301,
+   "seconds": 12.004,
+   "avg_fps": 524.913,
+   "low_1pct_fps": 9.024,
+   "low_01pct_fps": 1.125,
+   "p50_ms": 0.555,
+   "p95_ms": 2.072,
+   "p99_ms": 4.067,
+   "p999_ms": 282.455,
+   "max_ms": 3525.74,
+   "cpu_p50_ms": 0.531,
+   "gpu_p50_ms": 0.218,
+   "histogram": [
+    4878,
+    1060,
+    217,
+    86,
+    19,
+    15,
+    6,
+    2,
+    5,
+    0,
+    1,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    2,
+    0,
+    4,
+    3,
+    1
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 9869,
+   "seconds": 12.001,
+   "avg_fps": 822.353,
+   "low_1pct_fps": 138.293,
+   "low_01pct_fps": 72.479,
+   "p50_ms": 0.976,
+   "p95_ms": 2.871,
+   "p99_ms": 5.065,
+   "p999_ms": 9.942,
+   "max_ms": 23.337,
+   "cpu_p50_ms": 0.925,
+   "gpu_p50_ms": 0.245,
+   "histogram": [
+    5262,
+    3404,
+    771,
+    248,
+    81,
+    49,
+    23,
+    11,
+    12,
+    3,
+    0,
+    3,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 14570,
+   "seconds": 12.001,
+   "avg_fps": 1214.059,
+   "low_1pct_fps": 243.388,
+   "low_01pct_fps": 138.345,
+   "p50_ms": 0.655,
+   "p95_ms": 1.486,
+   "p99_ms": 2.883,
+   "p999_ms": 5.366,
+   "max_ms": 26.145,
+   "cpu_p50_ms": 0.62,
+   "gpu_p50_ms": 0.239,
+   "histogram": [
+    11502,
+    2683,
+    257,
+    77,
+    25,
+    23,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 4595,
+   "seconds": 11.999,
+   "avg_fps": 382.944,
+   "low_1pct_fps": 54.933,
+   "low_01pct_fps": 12.974,
+   "p50_ms": 2.269,
+   "p95_ms": 5.193,
+   "p99_ms": 8.719,
+   "p999_ms": 21.933,
+   "max_ms": 243.247,
+   "cpu_p50_ms": 1.826,
+   "gpu_p50_ms": 0.502,
+   "histogram": [
+    273,
+    1654,
+    1395,
+    836,
+    172,
+    122,
+    52,
+    38,
+    26,
+    10,
+    7,
+    5,
+    0,
+    2,
+    1,
+    0,
+    0,
+    0,
+    1,
+    0,
+    1,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 13964,
+   "seconds": 12.001,
+   "avg_fps": 1163.61,
+   "low_1pct_fps": 244.255,
+   "low_01pct_fps": 152.87,
+   "p50_ms": 0.682,
+   "p95_ms": 1.524,
+   "p99_ms": 2.877,
+   "p999_ms": 5.801,
+   "max_ms": 7.977,
+   "cpu_p50_ms": 0.57,
+   "gpu_p50_ms": 0.467,
+   "histogram": [
+    11067,
+    2532,
+    235,
+    82,
+    23,
+    16,
+    6,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 13777,
+   "seconds": 12.0,
+   "avg_fps": 1148.071,
+   "low_1pct_fps": 236.351,
+   "low_01pct_fps": 144.264,
+   "p50_ms": 0.691,
+   "p95_ms": 1.637,
+   "p99_ms": 3.131,
+   "p999_ms": 5.794,
+   "max_ms": 9.301,
+   "cpu_p50_ms": 0.57,
+   "gpu_p50_ms": 0.465,
+   "histogram": [
+    10826,
+    2511,
+    284,
+    106,
+    23,
+    16,
+    5,
+    5,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 1224,
+   "seconds": 11.322,
+   "avg_fps": 108.108,
+   "low_1pct_fps": 1.252,
+   "low_01pct_fps": 0.202,
+   "p50_ms": 0.439,
+   "p95_ms": 3.015,
+   "p99_ms": 7.359,
+   "p999_ms": 2880.23,
+   "max_ms": 7005.436,
+   "cpu_p50_ms": 0.303,
+   "gpu_p50_ms": 0.258,
+   "histogram": [
+    1081,
+    31,
+    49,
+    10,
+    3,
+    7,
+    23,
+    12,
+    4,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    2
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 15695,
+   "seconds": 12.0,
+   "avg_fps": 1307.912,
+   "low_1pct_fps": 292.881,
+   "low_01pct_fps": 132.042,
+   "p50_ms": 0.624,
+   "p95_ms": 1.219,
+   "p99_ms": 2.173,
+   "p999_ms": 4.841,
+   "max_ms": 16.764,
+   "cpu_p50_ms": 0.551,
+   "gpu_p50_ms": 0.401,
+   "histogram": [
+    13558,
+    1932,
+    140,
+    37,
+    14,
+    6,
+    3,
+    1,
+    1,
+    1,
+    0,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 9476,
+   "seconds": 12.0,
+   "avg_fps": 789.641,
+   "low_1pct_fps": 109.83,
+   "low_01pct_fps": 53.941,
+   "p50_ms": 0.802,
+   "p95_ms": 3.406,
+   "p99_ms": 5.844,
+   "p999_ms": 14.977,
+   "max_ms": 22.481,
+   "cpu_p50_ms": 0.686,
+   "gpu_p50_ms": 0.403,
+   "histogram": [
+    5819,
+    2151,
+    787,
+    455,
+    112,
+    65,
+    36,
+    18,
+    7,
+    7,
+    7,
+    5,
+    4,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 5352,
+   "seconds": 11.878,
+   "avg_fps": 450.565,
+   "low_1pct_fps": 24.389,
+   "low_01pct_fps": 3.577,
+   "p50_ms": 1.431,
+   "p95_ms": 4.548,
+   "p99_ms": 7.601,
+   "p999_ms": 96.086,
+   "max_ms": 714.027,
+   "cpu_p50_ms": 1.376,
+   "gpu_p50_ms": 0.398,
+   "histogram": [
+    1412,
+    2323,
+    811,
+    460,
+    138,
+    84,
+    49,
+    34,
+    13,
+    9,
+    8,
+    2,
+    1,
+    1,
+    0,
+    1,
+    0,
+    0,
+    1,
+    2,
+    1,
+    1,
+    1,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 8789,
+   "seconds": 12.001,
+   "avg_fps": 732.365,
+   "low_1pct_fps": 136.06,
+   "low_01pct_fps": 79.749,
+   "p50_ms": 0.972,
+   "p95_ms": 3.329,
+   "p99_ms": 5.68,
+   "p999_ms": 9.7,
+   "max_ms": 18.289,
+   "cpu_p50_ms": 0.935,
+   "gpu_p50_ms": 0.383,
+   "histogram": [
+    4529,
+    3007,
+    715,
+    287,
+    120,
+    61,
+    37,
+    16,
+    12,
+    1,
+    1,
+    2,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 11461,
+   "seconds": 12.001,
+   "avg_fps": 955.041,
+   "low_1pct_fps": 193.34,
+   "low_01pct_fps": 133.895,
+   "p50_ms": 0.787,
+   "p95_ms": 2.026,
+   "p99_ms": 3.953,
+   "p999_ms": 6.511,
+   "max_ms": 9.761,
+   "cpu_p50_ms": 0.765,
+   "gpu_p50_ms": 0.379,
+   "histogram": [
+    7754,
+    3114,
+    328,
+    165,
+    46,
+    33,
+    14,
+    5,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "horizon-desktop"
+}
@@ -0,0 +1,854 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-11-04T12:44:40Z",
+ "app": {
+  "name": "horizon-client",
+  "version": "nightly-2026-11-04-67dad0d",
+  "commit": "67dad0d"
+ },
+ "hardware": {
+  "os": "macos",
+  "arch": "aarch64",
+  "cpu_threads": 14,
+  "os_version": "27.0.1",
+  "cpu": "Apple M4 Pro",
+  "ram_mb": 65536,
+  "gpu": {
+   "name": "Apple M4 Pro",
+   "vendor": "",
+   "driver": "",
+   "backend": "metal",
+   "kind": "integrated"
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 12,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": true,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "load_avg_1m": 17.39,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 1516.155,
+   "stdev": 34.227,
+   "min": 1476.782,
+   "max": 1538.813,
+   "ci95": 85.032
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 4080.9,
+   "stdev": 748.712,
+   "min": 3273.516,
+   "max": 4752.301,
+   "ci95": 1860.054
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 3363.749,
+   "stdev": 224.552,
+   "min": 3105.622,
+   "max": 3514.059,
+   "ci95": 557.864
+  },
+  "chunks.village.meshed_count": {
+   "n": 3,
+   "mean": 15473.667,
+   "stdev": 339.602,
+   "min": 15123.0,
+   "max": 15801.0,
+   "ci95": 843.686
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 999.753,
+   "stdev": 41.901,
+   "min": 970.527,
+   "max": 1047.758,
+   "ci95": 104.095
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 336.821,
+   "stdev": 17.834,
+   "min": 318.068,
+   "max": 353.566,
+   "ci95": 44.306
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 263.782,
+   "stdev": 31.556,
+   "min": 227.767,
+   "max": 286.582,
+   "ci95": 78.395
+  },
+  "memory.village.rss_mb": {
+   "n": 3,
+   "mean": 1147.654,
+   "stdev": 31.82,
+   "min": 1116.875,
+   "max": 1180.422,
+   "ci95": 79.052
+  },
+  "tick.village.client_ms": {
+   "n": 3,
+   "mean": 0.414,
+   "stdev": 0.036,
+   "min": 0.373,
+   "max": 0.44,
+   "ci95": 0.089
+  },
+  "cpu.village.p50_ms": {
+   "n": 3,
+   "mean": 0.52,
+   "stdev": 0.071,
+   "min": 0.44,
+   "max": 0.577,
+   "ci95": 0.177
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 3685.368,
+   "stdev": 844.43,
+   "min": 2932.117,
+   "max": 4598.204,
+   "ci95": 2097.85
+  },
+  "chunks.forest.meshed_count": {
+   "n": 3,
+   "mean": 16795.333,
+   "stdev": 437.802,
+   "min": 16325.0,
+   "max": 17191.0,
+   "ci95": 1087.648
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 592.615,
+   "stdev": 20.339,
+   "min": 580.401,
+   "max": 616.094,
+   "ci95": 50.529
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 250.069,
+   "stdev": 31.227,
+   "min": 217.065,
+   "max": 279.149,
+   "ci95": 77.58
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 151.684,
+   "stdev": 77.064,
+   "min": 64.033,
+   "max": 208.811,
+   "ci95": 191.454
+  },
+  "memory.forest.rss_mb": {
+   "n": 3,
+   "mean": 1064.344,
+   "stdev": 148.185,
+   "min": 901.203,
+   "max": 1190.609,
+   "ci95": 368.142
+  },
+  "tick.forest.client_ms": {
+   "n": 3,
+   "mean": 0.424,
+   "stdev": 0.003,
+   "min": 0.422,
+   "max": 0.427,
+   "ci95": 0.007
+  },
+  "cpu.forest.p50_ms": {
+   "n": 3,
+   "mean": 0.617,
+   "stdev": 0.016,
+   "min": 0.599,
+   "max": 0.629,
+   "ci95": 0.039
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 3594.311,
+   "stdev": 1381.026,
+   "min": 2011.153,
+   "max": 4551.541,
+   "ci95": 3430.936
+  },
+  "chunks.ocean.meshed_count": {
+   "n": 3,
+   "mean": 14527.0,
+   "stdev": 319.629,
+   "min": 14166.0,
+   "max": 14774.0,
+   "ci95": 794.068
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 789.003,
+   "stdev": 25.076,
+   "min": 766.83,
+   "max": 816.216,
+   "ci95": 62.297
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 276.887,
+   "stdev": 51.785,
+   "min": 217.373,
+   "max": 311.665,
+   "ci95": 128.651
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 169.278,
+   "stdev": 29.119,
+   "min": 137.156,
+   "max": 193.944,
+   "ci95": 72.341
+  },
+  "memory.ocean.rss_mb": {
+   "n": 3,
+   "mean": 982.995,
+   "stdev": 287.819,
+   "min": 651.109,
+   "max": 1164.063,
+   "ci95": 715.039
+  },
+  "tick.ocean.client_ms": {
+   "n": 3,
+   "mean": 0.397,
+   "stdev": 0.028,
+   "min": 0.38,
+   "max": 0.429,
+   "ci95": 0.069
+  },
+  "cpu.ocean.p50_ms": {
+   "n": 3,
+   "mean": 0.569,
+   "stdev": 0.045,
+   "min": 0.533,
+   "max": 0.62,
+   "ci95": 0.112
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 5682.993,
+   "stdev": 1272.063,
+   "min": 4476.873,
+   "max": 7012.069,
+   "ci95": 3160.234
+  },
+  "chunks.mountain.meshed_count": {
+   "n": 3,
+   "mean": 15640.0,
+   "stdev": 204.105,
+   "min": 15507.0,
+   "max": 15875.0,
+   "ci95": 507.067
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 716.475,
+   "stdev": 8.139,
+   "min": 707.613,
+   "max": 723.617,
+   "ci95": 20.221
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 313.736,
+   "stdev": 3.759,
+   "min": 311.007,
+   "max": 318.023,
+   "ci95": 9.338
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 270.042,
+   "stdev": 19.572,
+   "min": 247.802,
+   "max": 284.642,
+   "ci95": 48.624
+  },
+  "memory.mountain.rss_mb": {
+   "n": 3,
+   "mean": 997.474,
+   "stdev": 231.733,
+   "min": 790.266,
+   "max": 1247.703,
+   "ci95": 575.704
+  },
+  "tick.mountain.client_ms": {
+   "n": 3,
+   "mean": 0.385,
+   "stdev": 0.023,
+   "min": 0.359,
+   "max": 0.401,
+   "ci95": 0.057
+  },
+  "cpu.mountain.p50_ms": {
+   "n": 3,
+   "mean": 0.609,
+   "stdev": 0.044,
+   "min": 0.56,
+   "max": 0.645,
+   "ci95": 0.109
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 1213.255,
+   "stdev": 81.897,
+   "min": 1136.078,
+   "max": 1299.172,
+   "ci95": 203.461
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 1034.279,
+   "stdev": 188.802,
+   "min": 816.453,
+   "max": 1150.961,
+   "ci95": 469.049
+  },
+  "memory.footprint_peak_mb": {
+   "n": 3,
+   "mean": 2167.747,
+   "stdev": 14.039,
+   "min": 2153.721,
+   "max": 2181.799,
+   "ci95": 34.878
+  },
+  "memory.footprint_steady_mb": {
+   "n": 3,
+   "mean": 1889.468,
+   "stdev": 24.444,
+   "min": 1862.799,
+   "max": 1910.807,
+   "ci95": 60.727
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 12573,
+   "seconds": 12.0,
+   "avg_fps": 1047.758,
+   "low_1pct_fps": 353.566,
+   "low_01pct_fps": 286.582,
+   "p50_ms": 0.921,
+   "p95_ms": 1.077,
+   "p99_ms": 2.675,
+   "p999_ms": 2.946,
+   "max_ms": 5.36,
+   "cpu_p50_ms": 0.44,
+   "gpu_p50_ms": 0.914,
+   "histogram": [
+    11056,
+    1291,
+    218,
+    6,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 11646,
+   "seconds": 12.0,
+   "avg_fps": 970.527,
+   "low_1pct_fps": 318.068,
+   "low_01pct_fps": 227.767,
+   "p50_ms": 0.973,
+   "p95_ms": 1.264,
+   "p99_ms": 2.805,
+   "p999_ms": 3.808,
+   "max_ms": 5.305,
+   "cpu_p50_ms": 0.577,
+   "gpu_p50_ms": 0.969,
+   "histogram": [
+    7035,
+    4334,
+    230,
+    39,
+    6,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 11771,
+   "seconds": 11.999,
+   "avg_fps": 980.973,
+   "low_1pct_fps": 338.828,
+   "low_01pct_fps": 276.996,
+   "p50_ms": 0.985,
+   "p95_ms": 1.157,
+   "p99_ms": 2.779,
+   "p999_ms": 3.068,
+   "max_ms": 4.308,
+   "cpu_p50_ms": 0.542,
+   "gpu_p50_ms": 0.98,
+   "histogram": [
+    6880,
+    4663,
+    208,
+    18,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 7394,
+   "seconds": 12.001,
+   "avg_fps": 616.094,
+   "low_1pct_fps": 253.993,
+   "low_01pct_fps": 182.207,
+   "p50_ms": 1.565,
+   "p95_ms": 1.915,
+   "p99_ms": 3.329,
+   "p999_ms": 4.661,
+   "max_ms": 7.32,
+   "cpu_p50_ms": 0.599,
+   "gpu_p50_ms": 1.551,
+   "histogram": [
+    82,
+    6988,
+    144,
+    162,
+    14,
+    2,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 6965,
+   "seconds": 12.0,
+   "avg_fps": 580.401,
+   "low_1pct_fps": 217.065,
+   "low_01pct_fps": 64.033,
+   "p50_ms": 1.654,
+   "p95_ms": 1.983,
+   "p99_ms": 3.233,
+   "p999_ms": 3.893,
+   "max_ms": 81.863,
+   "cpu_p50_ms": 0.629,
+   "gpu_p50_ms": 1.645,
+   "histogram": [
+    11,
+    6622,
+    153,
+    174,
+    4,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 6977,
+   "seconds": 12.001,
+   "avg_fps": 581.35,
+   "low_1pct_fps": 279.149,
+   "low_01pct_fps": 208.811,
+   "p50_ms": 1.659,
+   "p95_ms": 2.006,
+   "p99_ms": 3.273,
+   "p999_ms": 3.982,
+   "max_ms": 5.889,
+   "cpu_p50_ms": 0.623,
+   "gpu_p50_ms": 1.653,
+   "histogram": [
+    17,
+    6606,
+    164,
+    186,
+    1,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 9793,
+   "seconds": 11.998,
+   "avg_fps": 816.216,
+   "low_1pct_fps": 301.624,
+   "low_01pct_fps": 176.734,
+   "p50_ms": 1.171,
+   "p95_ms": 1.499,
+   "p99_ms": 2.928,
+   "p999_ms": 3.333,
+   "max_ms": 23.472,
+   "cpu_p50_ms": 0.533,
+   "gpu_p50_ms": 1.163,
+   "histogram": [
+    259,
+    9293,
+    182,
+    56,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 9202,
+   "seconds": 12.0,
+   "avg_fps": 766.83,
+   "low_1pct_fps": 217.373,
+   "low_01pct_fps": 137.156,
+   "p50_ms": 1.226,
+   "p95_ms": 1.912,
+   "p99_ms": 3.396,
+   "p999_ms": 6.003,
+   "max_ms": 13.562,
+   "cpu_p50_ms": 0.62,
+   "gpu_p50_ms": 1.219,
+   "histogram": [
+    635,
+    8130,
+    261,
+    124,
+    27,
+    15,
+    7,
+    2,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 9408,
+   "seconds": 12.001,
+   "avg_fps": 783.964,
+   "low_1pct_fps": 311.665,
+   "low_01pct_fps": 193.944,
+   "p50_ms": 1.22,
+   "p95_ms": 1.541,
+   "p99_ms": 2.865,
+   "p999_ms": 3.298,
+   "max_ms": 13.861,
+   "cpu_p50_ms": 0.555,
+   "gpu_p50_ms": 1.214,
+   "histogram": [
+    100,
+    9066,
+    204,
+    34,
+    2,
+    0,
+    1,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 8618,
+   "seconds": 12.0,
+   "avg_fps": 718.194,
+   "low_1pct_fps": 312.177,
+   "low_01pct_fps": 277.681,
+   "p50_ms": 1.338,
+   "p95_ms": 1.664,
+   "p99_ms": 3.068,
+   "p999_ms": 3.364,
+   "max_ms": 4.008,
+   "cpu_p50_ms": 0.622,
+   "gpu_p50_ms": 1.329,
+   "histogram": [
+    62,
+    8301,
+    130,
+    125,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 8492,
+   "seconds": 12.001,
+   "avg_fps": 707.613,
+   "low_1pct_fps": 311.007,
+   "low_01pct_fps": 284.642,
+   "p50_ms": 1.35,
+   "p95_ms": 1.707,
+   "p99_ms": 3.08,
+   "p999_ms": 3.329,
+   "max_ms": 3.796,
+   "cpu_p50_ms": 0.645,
+   "gpu_p50_ms": 1.342,
+   "histogram": [
+    32,
+    8216,
+    111,
+    133,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 8684,
+   "seconds": 12.001,
+   "avg_fps": 723.617,
+   "low_1pct_fps": 318.023,
+   "low_01pct_fps": 247.802,
+   "p50_ms": 1.318,
+   "p95_ms": 1.699,
+   "p99_ms": 2.875,
+   "p999_ms": 3.573,
+   "max_ms": 5.186,
+   "cpu_p50_ms": 0.56,
+   "gpu_p50_ms": 1.306,
+   "histogram": [
+    46,
+    8389,
+    199,
+    49,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "horizon-macmini"
+}
@@ -0,0 +1,854 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-11-04T13:17:26Z",
+ "app": {
+  "name": "horizon-client",
+  "version": "nightly-2026-11-04-67dad0d",
+  "commit": "67dad0d"
+ },
+ "hardware": {
+  "os": "macos",
+  "arch": "aarch64",
+  "cpu_threads": 14,
+  "os_version": "27.0.1",
+  "cpu": "Apple M4 Pro",
+  "ram_mb": 65536,
+  "gpu": {
+   "name": "Apple M4 Pro",
+   "vendor": "",
+   "driver": "",
+   "backend": "metal",
+   "kind": "integrated"
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 32,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": true,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "load_avg_1m": 17.712,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 1528.444,
+   "stdev": 181.21,
+   "min": 1319.58,
+   "max": 1643.783,
+   "ci95": 450.188
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 12368.716,
+   "stdev": 6475.37,
+   "min": 7168.429,
+   "max": 19621.62,
+   "ci95": 16087.01
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 6926.208,
+   "stdev": 3712.691,
+   "min": 4208.555,
+   "max": 11156.419,
+   "ci95": 9223.581
+  },
+  "chunks.village.meshed_count": {
+   "n": 3,
+   "mean": 46790.333,
+   "stdev": 1381.89,
+   "min": 45236.0,
+   "max": 47880.0,
+   "ci95": 3433.082
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 453.505,
+   "stdev": 14.384,
+   "min": 441.517,
+   "max": 469.455,
+   "ci95": 35.735
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 222.897,
+   "stdev": 10.449,
+   "min": 212.173,
+   "max": 233.048,
+   "ci95": 25.96
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 173.55,
+   "stdev": 31.798,
+   "min": 142.967,
+   "max": 206.437,
+   "ci95": 78.996
+  },
+  "memory.village.rss_mb": {
+   "n": 3,
+   "mean": 1544.565,
+   "stdev": 26.422,
+   "min": 1516.75,
+   "max": 1569.328,
+   "ci95": 65.64
+  },
+  "tick.village.client_ms": {
+   "n": 3,
+   "mean": 0.528,
+   "stdev": 0.018,
+   "min": 0.511,
+   "max": 0.548,
+   "ci95": 0.045
+  },
+  "cpu.village.p50_ms": {
+   "n": 3,
+   "mean": 1.496,
+   "stdev": 0.049,
+   "min": 1.453,
+   "max": 1.549,
+   "ci95": 0.121
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 8297.116,
+   "stdev": 689.909,
+   "min": 7716.447,
+   "max": 9059.776,
+   "ci95": 1713.966
+  },
+  "chunks.forest.meshed_count": {
+   "n": 3,
+   "mean": 78617.667,
+   "stdev": 494.532,
+   "min": 78228.0,
+   "max": 79174.0,
+   "ci95": 1228.586
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 216.265,
+   "stdev": 6.372,
+   "min": 209.501,
+   "max": 222.156,
+   "ci95": 15.831
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 137.027,
+   "stdev": 3.787,
+   "min": 133.07,
+   "max": 140.617,
+   "ci95": 9.408
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 114.683,
+   "stdev": 7.985,
+   "min": 106.585,
+   "max": 122.551,
+   "ci95": 19.839
+  },
+  "memory.forest.rss_mb": {
+   "n": 3,
+   "mean": 1420.638,
+   "stdev": 247.812,
+   "min": 1266.047,
+   "max": 1706.469,
+   "ci95": 615.649
+  },
+  "tick.forest.client_ms": {
+   "n": 3,
+   "mean": 0.423,
+   "stdev": 0.059,
+   "min": 0.355,
+   "max": 0.458,
+   "ci95": 0.148
+  },
+  "cpu.forest.p50_ms": {
+   "n": 3,
+   "mean": 1.605,
+   "stdev": 0.269,
+   "min": 1.295,
+   "max": 1.779,
+   "ci95": 0.668
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 8354.659,
+   "stdev": 2877.749,
+   "min": 5454.947,
+   "max": 11209.93,
+   "ci95": 7149.301
+  },
+  "chunks.ocean.meshed_count": {
+   "n": 3,
+   "mean": 74315.667,
+   "stdev": 63.106,
+   "min": 74246.0,
+   "max": 74369.0,
+   "ci95": 156.776
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 274.828,
+   "stdev": 4.993,
+   "min": 270.041,
+   "max": 280.004,
+   "ci95": 12.404
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 165.765,
+   "stdev": 7.21,
+   "min": 157.538,
+   "max": 170.985,
+   "ci95": 17.912
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 140.185,
+   "stdev": 9.74,
+   "min": 129.976,
+   "max": 149.377,
+   "ci95": 24.198
+  },
+  "memory.ocean.rss_mb": {
+   "n": 3,
+   "mean": 1306.578,
+   "stdev": 97.011,
+   "min": 1199.094,
+   "max": 1387.641,
+   "ci95": 241.007
+  },
+  "tick.ocean.client_ms": {
+   "n": 3,
+   "mean": 0.416,
+   "stdev": 0.029,
+   "min": 0.392,
+   "max": 0.448,
+   "ci95": 0.071
+  },
+  "cpu.ocean.p50_ms": {
+   "n": 3,
+   "mean": 1.636,
+   "stdev": 0.121,
+   "min": 1.496,
+   "max": 1.708,
+   "ci95": 0.301
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 17124.873,
+   "stdev": 3461.08,
+   "min": 13599.217,
+   "max": 20517.544,
+   "ci95": 8598.494
+  },
+  "chunks.mountain.meshed_count": {
+   "n": 3,
+   "mean": 91909.0,
+   "stdev": 815.603,
+   "min": 91157.0,
+   "max": 92776.0,
+   "ci95": 2026.235
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 242.657,
+   "stdev": 3.405,
+   "min": 240.66,
+   "max": 246.588,
+   "ci95": 8.459
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 110.95,
+   "stdev": 14.622,
+   "min": 99.907,
+   "max": 127.532,
+   "ci95": 36.325
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 51.329,
+   "stdev": 28.253,
+   "min": 30.391,
+   "max": 83.465,
+   "ci95": 70.191
+  },
+  "memory.mountain.rss_mb": {
+   "n": 3,
+   "mean": 1451.688,
+   "stdev": 127.471,
+   "min": 1310.969,
+   "max": 1559.43,
+   "ci95": 316.681
+  },
+  "tick.mountain.client_ms": {
+   "n": 3,
+   "mean": 0.614,
+   "stdev": 0.017,
+   "min": 0.594,
+   "max": 0.627,
+   "ci95": 0.043
+  },
+  "cpu.mountain.p50_ms": {
+   "n": 3,
+   "mean": 2.233,
+   "stdev": 0.05,
+   "min": 2.194,
+   "max": 2.289,
+   "ci95": 0.124
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 1697.984,
+   "stdev": 29.735,
+   "min": 1667.406,
+   "max": 1726.797,
+   "ci95": 73.871
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 1428.19,
+   "stdev": 120.658,
+   "min": 1333.0,
+   "max": 1563.891,
+   "ci95": 299.756
+  },
+  "memory.footprint_peak_mb": {
+   "n": 3,
+   "mean": 4921.753,
+   "stdev": 30.436,
+   "min": 4890.971,
+   "max": 4951.831,
+   "ci95": 75.613
+  },
+  "memory.footprint_steady_mb": {
+   "n": 3,
+   "mean": 4079.43,
+   "stdev": 10.978,
+   "min": 4068.049,
+   "max": 4089.956,
+   "ci95": 27.273
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 5634,
+   "seconds": 12.001,
+   "avg_fps": 469.455,
+   "low_1pct_fps": 223.469,
+   "low_01pct_fps": 171.246,
+   "p50_ms": 2.054,
+   "p95_ms": 2.492,
+   "p99_ms": 3.993,
+   "p999_ms": 5.425,
+   "max_ms": 6.645,
+   "cpu_p50_ms": 1.453,
+   "gpu_p50_ms": 1.965,
+   "histogram": [
+    0,
+    2082,
+    3324,
+    193,
+    24,
+    9,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 5395,
+   "seconds": 12.001,
+   "avg_fps": 449.543,
+   "low_1pct_fps": 233.048,
+   "low_01pct_fps": 206.437,
+   "p50_ms": 2.155,
+   "p95_ms": 2.611,
+   "p99_ms": 4.068,
+   "p999_ms": 4.456,
+   "max_ms": 5.305,
+   "cpu_p50_ms": 1.549,
+   "gpu_p50_ms": 2.043,
+   "histogram": [
+    0,
+    902,
+    4255,
+    206,
+    29,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 5298,
+   "seconds": 12.0,
+   "avg_fps": 441.517,
+   "low_1pct_fps": 212.173,
+   "low_01pct_fps": 142.967,
+   "p50_ms": 2.171,
+   "p95_ms": 3.249,
+   "p99_ms": 4.138,
+   "p999_ms": 5.591,
+   "max_ms": 9.676,
+   "cpu_p50_ms": 1.485,
+   "gpu_p50_ms": 2.092,
+   "histogram": [
+    0,
+    709,
+    4314,
+    229,
+    36,
+    6,
+    2,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 2606,
+   "seconds": 12.002,
+   "avg_fps": 217.137,
+   "low_1pct_fps": 140.617,
+   "low_01pct_fps": 106.585,
+   "p50_ms": 4.471,
+   "p95_ms": 5.926,
+   "p99_ms": 6.575,
+   "p999_ms": 7.735,
+   "max_ms": 12.187,
+   "cpu_p50_ms": 1.74,
+   "gpu_p50_ms": 4.238,
+   "histogram": [
+    0,
+    0,
+    0,
+    221,
+    2094,
+    172,
+    110,
+    8,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 2514,
+   "seconds": 12.0,
+   "avg_fps": 209.501,
+   "low_1pct_fps": 137.393,
+   "low_01pct_fps": 122.551,
+   "p50_ms": 4.627,
+   "p95_ms": 6.304,
+   "p99_ms": 6.93,
+   "p999_ms": 7.971,
+   "max_ms": 8.506,
+   "cpu_p50_ms": 1.779,
+   "gpu_p50_ms": 4.409,
+   "histogram": [
+    0,
+    0,
+    2,
+    35,
+    2097,
+    200,
+    162,
+    17,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 2667,
+   "seconds": 12.005,
+   "avg_fps": 222.156,
+   "low_1pct_fps": 133.07,
+   "low_01pct_fps": 114.913,
+   "p50_ms": 4.37,
+   "p95_ms": 5.756,
+   "p99_ms": 6.742,
+   "p999_ms": 8.444,
+   "max_ms": 8.984,
+   "cpu_p50_ms": 1.295,
+   "gpu_p50_ms": 4.152,
+   "histogram": [
+    0,
+    0,
+    0,
+    440,
+    1978,
+    144,
+    85,
+    16,
+    4,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 3294,
+   "seconds": 12.003,
+   "avg_fps": 274.44,
+   "low_1pct_fps": 157.538,
+   "low_01pct_fps": 129.976,
+   "p50_ms": 3.521,
+   "p95_ms": 4.814,
+   "p99_ms": 5.592,
+   "p999_ms": 7.491,
+   "max_ms": 7.868,
+   "cpu_p50_ms": 1.703,
+   "gpu_p50_ms": 3.277,
+   "histogram": [
+    0,
+    4,
+    55,
+    2967,
+    130,
+    122,
+    10,
+    6,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 3241,
+   "seconds": 12.002,
+   "avg_fps": 270.041,
+   "low_1pct_fps": 168.771,
+   "low_01pct_fps": 141.201,
+   "p50_ms": 3.578,
+   "p95_ms": 4.942,
+   "p99_ms": 5.631,
+   "p999_ms": 6.498,
+   "max_ms": 7.601,
+   "cpu_p50_ms": 1.708,
+   "gpu_p50_ms": 3.323,
+   "histogram": [
+    0,
+    2,
+    8,
+    2970,
+    110,
+    144,
+    5,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 3360,
+   "seconds": 12.0,
+   "avg_fps": 280.004,
+   "low_1pct_fps": 170.985,
+   "low_01pct_fps": 149.377,
+   "p50_ms": 3.477,
+   "p95_ms": 4.678,
+   "p99_ms": 5.462,
+   "p999_ms": 6.626,
+   "max_ms": 6.788,
+   "cpu_p50_ms": 1.496,
+   "gpu_p50_ms": 3.23,
+   "histogram": [
+    0,
+    1,
+    5,
+    3125,
+    129,
+    90,
+    10,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 2888,
+   "seconds": 12.0,
+   "avg_fps": 240.66,
+   "low_1pct_fps": 127.532,
+   "low_01pct_fps": 83.465,
+   "p50_ms": 3.984,
+   "p95_ms": 5.171,
+   "p99_ms": 6.823,
+   "p999_ms": 9.168,
+   "max_ms": 15.341,
+   "cpu_p50_ms": 2.194,
+   "gpu_p50_ms": 3.786,
+   "histogram": [
+    0,
+    0,
+    4,
+    2048,
+    638,
+    144,
+    33,
+    16,
+    3,
+    1,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 2889,
+   "seconds": 12.001,
+   "avg_fps": 240.722,
+   "low_1pct_fps": 99.907,
+   "low_01pct_fps": 40.132,
+   "p50_ms": 3.961,
+   "p95_ms": 5.706,
+   "p99_ms": 7.364,
+   "p999_ms": 12.597,
+   "max_ms": 49.156,
+   "cpu_p50_ms": 2.289,
+   "gpu_p50_ms": 3.802,
+   "histogram": [
+    0,
+    5,
+    126,
+    1859,
+    599,
+    194,
+    72,
+    22,
+    8,
+    1,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 2959,
+   "seconds": 12.0,
+   "avg_fps": 246.588,
+   "low_1pct_fps": 105.411,
+   "low_01pct_fps": 30.391,
+   "p50_ms": 3.851,
+   "p95_ms": 5.353,
+   "p99_ms": 6.248,
+   "p999_ms": 9.05,
+   "max_ms": 54.378,
+   "cpu_p50_ms": 2.216,
+   "gpu_p50_ms": 3.667,
+   "histogram": [
+    0,
+    2,
+    58,
+    2196,
+    462,
+    196,
+    32,
+    10,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "horizon-macmini"
+}
@@ -0,0 +1,42 @@
+# Horizon Nightly 2026-11-04 vs vanilla 26.3 on the Mac mini and the desktop (2026-11-04)
+
+> **The Mac mini reports (`*-macmini-rd*.json`) are offscreen, not comparable.** Horizon rendered offscreen (no presenting)
+> while vanilla drew into a window, so the Mac rows below are not a Horizon-vs-vanilla comparison, and the website does not
+> publish them: it keeps the Mac mini's 2026-10-22 runs. They are kept here only as a record of that day's offscreen run.
+
+The desktop runs are the ones behind playhorizon.dev/benchmarks as of 2026-11-04 (horizon-rust/horizon-site#58): `tools/perf_bench.py`
+reports, render distance 12 and 32, three games each, every game from a fresh world (seed 1234), 1280x720, VSync off. Files:
+`{horizon,vanilla}-macmini-rd{12,32}.json` and `{horizon,vanilla}-desktop-rd{12,32}.json` next to this page.
+
+## Builds
+
+- **Horizon:** the Nightly 2026-11-04 release bundle (67dad0d), as the launcher installs it: macOS arm64 on the Mac,
+  Linux x86_64 on the desktop. Its resources come from the bundle's own `horizon-prepare`. perf_bench ran from main
+  a55b9a2e52 and wrote that checkout's crate version and commit; `app.version` and `app.commit` were set to the bundle's by hand.
+- **Vanilla:** the 26.3 client jar with Fabric Loader and the driver mod, Java 25, the official launcher's JVM flags.
+
+## Machines and conditions
+
+- **Mac mini, Apple M4 Pro (14 cores, 20-core GPU), macOS: offscreen, not comparable.** The session was locked, so Horizon ran `--offscreen`: a locked
+  session gives a window no frames, and windowed Horizon measured 0 FPS. Vanilla drew into its window. Offscreen skips
+  presenting, which favours Horizon, so its averages aren't held at the 144 Hz display as they were on 2026-10-22. Each game
+  started at a 1-minute load of 17-18 (the run waited for < 20); during the runs the load rose to 30-50.
+- **Desktop, RTX 4080 + i7-13700KF, NixOS, NVIDIA 595.** Both games drew into a headless sway rendering on the RTX 4080 (never
+  on its screen), both through Wayland on Vulkan. Vanilla went through SDL's Wayland driver: through Xwayland each of its
+  frames took about 2 s on this day. The machine also runs CI and agents' builds: each game started at a load of 28-30 on
+  24 threads (the run waited for < 30) and the load rose to 40-70 during the runs. Vanilla at RD 32 crashed twice under that
+  load (`GPU timeout attempting to acquire next frame`) before a third series finished. Start-up times are inflated by the
+  load and by a cold disk on each series' first start (start → world up to 130-235 s).
+- **Order:** RD 12 ran Horizon then vanilla; RD 32 ran vanilla then Horizon.
+
+## Results (average over the flights of the three games; FPS average / 1% low)
+
+| Machine | RD | Horizon | Vanilla | Horizon ÷ vanilla (avg, 1% low) |
+|---|---|---|---|---|
+| Mac mini (**offscreen, not comparable**) | 12 | 774 / 294 | 132 / 27 | — |
+| Mac mini (**offscreen, not comparable**) | 32 | 297 / 159 | 68 / 16 | — |
+| Desktop | 12 | 2,224 / 308 | 1,824 / 201 | 1.2x, 1.5x |
+| Desktop | 32 | 800 / 140 | 696 / 64 | 1.15x, 2.2x |
+
+Neither machine was idle, so these say how both games behave on busy machines. They are not clean ratios; for those, see
+`windows-9800x3d-5080-2026-10-29.md`. The scripts and logs are in horizon-parity `shots/site-bench-2026-11-04/`.
@@ -0,0 +1,787 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-11-04T13:28:55Z",
+ "app": {
+  "name": "minecraft",
+  "version": "26.3",
+  "mods": [
+   {
+    "name": "fabric-loader",
+    "version": "0.19.5"
+   }
+  ]
+ },
+ "hardware": {
+  "os": "linux",
+  "arch": "x86_64",
+  "cpu_threads": 24,
+  "os_version": "NixOS 26.05 (Yarara) (kernel 6.18.57)",
+  "cpu": "13th Gen Intel(R) Core(TM) i7-13700KF",
+  "ram_mb": 31904,
+  "gpu": {
+   "name": "NVIDIA GeForce RTX 4080",
+   "vendor": "NVIDIA",
+   "driver": "1.4.329 NVIDIA 595.71.05",
+   "backend": "vulkan",
+   "kind": ""
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 12,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "load_avg_1m": 28.788,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 121075.467,
+   "stdev": 30646.429,
+   "min": 93272.034,
+   "max": 153935.834,
+   "ci95": 76136.094
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 191063.8,
+   "stdev": 34368.16,
+   "min": 153895.533,
+   "max": 221692.034,
+   "ci95": 85382.134
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 18724.322,
+   "stdev": 9639.048,
+   "min": 13107.549,
+   "max": 29854.376,
+   "ci95": 23946.655
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 2161.532,
+   "stdev": 287.109,
+   "min": 1830.069,
+   "max": 2332.81,
+   "ci95": 713.276
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 162.575,
+   "stdev": 29.799,
+   "min": 136.023,
+   "max": 194.804,
+   "ci95": 74.03
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 27.752,
+   "stdev": 3.186,
+   "min": 24.403,
+   "max": 30.746,
+   "ci95": 7.916
+  },
+  "memory.village.gpu_mb": {
+   "n": 3,
+   "mean": 13.0,
+   "stdev": 0.0,
+   "min": 13.0,
+   "max": 13.0,
+   "ci95": 0.0
+  },
+  "memory.village.rss_mb": {
+   "n": 3,
+   "mean": 2902.054,
+   "stdev": 158.708,
+   "min": 2747.244,
+   "max": 3064.393,
+   "ci95": 394.285
+  },
+  "tick.village.client_ms": {
+   "n": 3,
+   "mean": 0.691,
+   "stdev": 0.097,
+   "min": 0.601,
+   "max": 0.794,
+   "ci95": 0.241
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 8852.332,
+   "stdev": 530.809,
+   "min": 8350.811,
+   "max": 9408.241,
+   "ci95": 1318.709
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 1841.581,
+   "stdev": 1186.781,
+   "min": 471.209,
+   "max": 2529.847,
+   "ci95": 2948.365
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 255.087,
+   "stdev": 217.128,
+   "min": 5.798,
+   "max": 402.877,
+   "ci95": 539.419
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 92.882,
+   "stdev": 81.722,
+   "min": 0.61,
+   "max": 156.13,
+   "ci95": 203.024
+  },
+  "memory.forest.gpu_mb": {
+   "n": 3,
+   "mean": 13.0,
+   "stdev": 0.0,
+   "min": 13.0,
+   "max": 13.0,
+   "ci95": 0.0
+  },
+  "memory.forest.rss_mb": {
+   "n": 3,
+   "mean": 3008.178,
+   "stdev": 149.07,
+   "min": 2875.082,
+   "max": 3169.256,
+   "ci95": 370.34
+  },
+  "tick.forest.client_ms": {
+   "n": 3,
+   "mean": 0.687,
+   "stdev": 0.132,
+   "min": 0.562,
+   "max": 0.825,
+   "ci95": 0.327
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 21215.745,
+   "stdev": 22821.547,
+   "min": 8034.077,
+   "max": 47567.797,
+   "ci95": 56696.441
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 1525.483,
+   "stdev": 1472.651,
+   "min": 633.984,
+   "max": 3225.275,
+   "ci95": 3658.563
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 191.398,
+   "stdev": 272.942,
+   "min": 10.346,
+   "max": 505.335,
+   "ci95": 678.08
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 49.506,
+   "stdev": 66.145,
+   "min": 1.104,
+   "max": 124.874,
+   "ci95": 164.326
+  },
+  "memory.ocean.gpu_mb": {
+   "n": 3,
+   "mean": 13.0,
+   "stdev": 0.0,
+   "min": 13.0,
+   "max": 13.0,
+   "ci95": 0.0
+  },
+  "memory.ocean.rss_mb": {
+   "n": 3,
+   "mean": 3062.136,
+   "stdev": 128.594,
+   "min": 2962.541,
+   "max": 3207.313,
+   "ci95": 319.472
+  },
+  "tick.ocean.client_ms": {
+   "n": 3,
+   "mean": 1.029,
+   "stdev": 0.573,
+   "min": 0.595,
+   "max": 1.678,
+   "ci95": 1.423
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 33255.15,
+   "stdev": 20451.99,
+   "min": 16655.144,
+   "max": 56102.104,
+   "ci95": 50809.661
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 1769.12,
+   "stdev": 996.863,
+   "min": 818.512,
+   "max": 2806.557,
+   "ci95": 2476.544
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 195.916,
+   "stdev": 195.285,
+   "min": 11.586,
+   "max": 400.567,
+   "ci95": 485.154
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 52.202,
+   "stdev": 51.208,
+   "min": 1.461,
+   "max": 103.864,
+   "ci95": 127.217
+  },
+  "memory.mountain.gpu_mb": {
+   "n": 3,
+   "mean": 13.0,
+   "stdev": 0.0,
+   "min": 13.0,
+   "max": 13.0,
+   "ci95": 0.0
+  },
+  "memory.mountain.rss_mb": {
+   "n": 3,
+   "mean": 2957.948,
+   "stdev": 340.935,
+   "min": 2586.504,
+   "max": 3256.625,
+   "ci95": 846.998
+  },
+  "tick.mountain.client_ms": {
+   "n": 3,
+   "mean": 1.436,
+   "stdev": 1.406,
+   "min": 0.462,
+   "max": 3.048,
+   "ci95": 3.494
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 3107.953,
+   "stdev": 141.888,
+   "min": 3020.105,
+   "max": 3271.645,
+   "ci95": 352.498
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 2985.317,
+   "stdev": 210.327,
+   "min": 2761.164,
+   "max": 3178.35,
+   "ci95": 522.523
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 21963,
+   "seconds": 12.001,
+   "avg_fps": 1830.069,
+   "low_1pct_fps": 136.023,
+   "low_01pct_fps": 30.746,
+   "p50_ms": 0.331,
+   "p95_ms": 1.153,
+   "p99_ms": 3.001,
+   "p999_ms": 9.997,
+   "max_ms": 326.36,
+   "histogram": [
+    20336,
+    1238,
+    167,
+    108,
+    40,
+    23,
+    12,
+    10,
+    8,
+    7,
+    5,
+    1,
+    2,
+    1,
+    2,
+    0,
+    1,
+    1,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 27994,
+   "seconds": 12.0,
+   "avg_fps": 2332.81,
+   "low_1pct_fps": 194.804,
+   "low_01pct_fps": 28.107,
+   "p50_ms": 0.321,
+   "p95_ms": 0.771,
+   "p99_ms": 1.356,
+   "p999_ms": 3.836,
+   "max_ms": 331.931,
+   "histogram": [
+    27270,
+    652,
+    34,
+    13,
+    5,
+    2,
+    3,
+    4,
+    3,
+    2,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    1,
+    1,
+    0,
+    2,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 27861,
+   "seconds": 12.0,
+   "avg_fps": 2321.717,
+   "low_1pct_fps": 156.898,
+   "low_01pct_fps": 24.403,
+   "p50_ms": 0.281,
+   "p95_ms": 0.852,
+   "p99_ms": 1.73,
+   "p999_ms": 6.331,
+   "max_ms": 301.991,
+   "histogram": [
+    26932,
+    726,
+    124,
+    42,
+    4,
+    4,
+    3,
+    2,
+    9,
+    2,
+    3,
+    1,
+    1,
+    1,
+    0,
+    1,
+    1,
+    0,
+    2,
+    0,
+    2,
+    1,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 30359,
+   "seconds": 12.0,
+   "avg_fps": 2529.847,
+   "low_1pct_fps": 356.586,
+   "low_01pct_fps": 121.906,
+   "p50_ms": 0.353,
+   "p95_ms": 0.563,
+   "p99_ms": 1.405,
+   "p999_ms": 4.444,
+   "max_ms": 20.302,
+   "histogram": [
+    29756,
+    460,
+    57,
+    52,
+    11,
+    5,
+    3,
+    5,
+    2,
+    4,
+    1,
+    0,
+    2,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 5781,
+   "seconds": 12.268,
+   "avg_fps": 471.209,
+   "low_1pct_fps": 5.798,
+   "low_01pct_fps": 0.61,
+   "p50_ms": 0.359,
+   "p95_ms": 0.77,
+   "p99_ms": 1.78,
+   "p999_ms": 20.826,
+   "max_ms": 5834.37,
+   "histogram": [
+    5586,
+    158,
+    12,
+    11,
+    0,
+    1,
+    3,
+    2,
+    0,
+    0,
+    2,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    2,
+    3
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 30285,
+   "seconds": 12.0,
+   "avg_fps": 2523.687,
+   "low_1pct_fps": 402.877,
+   "low_01pct_fps": 156.13,
+   "p50_ms": 0.351,
+   "p95_ms": 0.539,
+   "p99_ms": 1.574,
+   "p999_ms": 3.683,
+   "max_ms": 16.022,
+   "histogram": [
+    29666,
+    490,
+    74,
+    35,
+    7,
+    2,
+    2,
+    1,
+    1,
+    5,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 11685,
+   "seconds": 16.293,
+   "avg_fps": 717.19,
+   "low_1pct_fps": 10.346,
+   "low_01pct_fps": 1.104,
+   "p50_ms": 0.299,
+   "p95_ms": 1.119,
+   "p99_ms": 2.568,
+   "p999_ms": 12.054,
+   "max_ms": 5250.537,
+   "histogram": [
+    10993,
+    502,
+    102,
+    39,
+    14,
+    8,
+    6,
+    4,
+    4,
+    1,
+    1,
+    2,
+    0,
+    2,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    2,
+    0,
+    4
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 38704,
+   "seconds": 12.0,
+   "avg_fps": 3225.275,
+   "low_1pct_fps": 505.335,
+   "low_01pct_fps": 124.874,
+   "p50_ms": 0.283,
+   "p95_ms": 0.36,
+   "p99_ms": 0.909,
+   "p999_ms": 2.015,
+   "max_ms": 132.801,
+   "histogram": [
+    38385,
+    279,
+    25,
+    3,
+    2,
+    0,
+    1,
+    0,
+    2,
+    4,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 7609,
+   "seconds": 12.002,
+   "avg_fps": 633.984,
+   "low_1pct_fps": 58.513,
+   "low_01pct_fps": 22.539,
+   "p50_ms": 1.141,
+   "p95_ms": 4.438,
+   "p99_ms": 9.113,
+   "p999_ms": 27.496,
+   "max_ms": 64.424,
+   "histogram": [
+    3452,
+    2398,
+    956,
+    368,
+    143,
+    96,
+    61,
+    46,
+    20,
+    29,
+    6,
+    10,
+    6,
+    7,
+    7,
+    0,
+    1,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 10168,
+   "seconds": 12.423,
+   "avg_fps": 818.512,
+   "low_1pct_fps": 11.586,
+   "low_01pct_fps": 1.461,
+   "p50_ms": 0.267,
+   "p95_ms": 0.892,
+   "p99_ms": 3.176,
+   "p999_ms": 198.757,
+   "max_ms": 1882.64,
+   "histogram": [
+    9733,
+    205,
+    121,
+    49,
+    12,
+    9,
+    8,
+    2,
+    2,
+    0,
+    1,
+    2,
+    1,
+    3,
+    0,
+    3,
+    2,
+    0,
+    0,
+    2,
+    4,
+    5,
+    1,
+    3
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 33679,
+   "seconds": 12.0,
+   "avg_fps": 2806.557,
+   "low_1pct_fps": 400.567,
+   "low_01pct_fps": 103.864,
+   "p50_ms": 0.324,
+   "p95_ms": 0.411,
+   "p99_ms": 1.167,
+   "p999_ms": 3.508,
+   "max_ms": 83.572,
+   "histogram": [
+    33272,
+    315,
+    46,
+    22,
+    2,
+    1,
+    4,
+    2,
+    9,
+    1,
+    2,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 20188,
+   "seconds": 12.0,
+   "avg_fps": 1682.292,
+   "low_1pct_fps": 175.594,
+   "low_01pct_fps": 51.28,
+   "p50_ms": 0.374,
+   "p95_ms": 1.37,
+   "p99_ms": 2.821,
+   "p999_ms": 8.947,
+   "max_ms": 53.494,
+   "histogram": [
+    18109,
+    1592,
+    314,
+    83,
+    36,
+    19,
+    7,
+    6,
+    6,
+    1,
+    3,
+    1,
+    4,
+    2,
+    3,
+    0,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "vanilla-desktop"
+}
@@ -0,0 +1,787 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-11-04T15:46:25Z",
+ "app": {
+  "name": "minecraft",
+  "version": "26.3",
+  "mods": [
+   {
+    "name": "fabric-loader",
+    "version": "0.19.5"
+   }
+  ]
+ },
+ "hardware": {
+  "os": "linux",
+  "arch": "x86_64",
+  "cpu_threads": 24,
+  "os_version": "NixOS 26.05 (Yarara) (kernel 6.18.57)",
+  "cpu": "13th Gen Intel(R) Core(TM) i7-13700KF",
+  "ram_mb": 31904,
+  "gpu": {
+   "name": "NVIDIA GeForce RTX 4080",
+   "vendor": "NVIDIA",
+   "driver": "1.4.329 NVIDIA 595.71.05",
+   "backend": "vulkan",
+   "kind": ""
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 32,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "load_avg_1m": 28.799,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 112742.179,
+   "stdev": 27885.804,
+   "min": 81110.692,
+   "max": 133773.748,
+   "ci95": 69277.769
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 235049.179,
+   "stdev": 31461.958,
+   "min": 203486.748,
+   "max": 266409.692,
+   "ci95": 78162.144
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 79828.05,
+   "stdev": 109107.365,
+   "min": 16685.972,
+   "max": 205814.266,
+   "ci95": 271059.597
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 525.667,
+   "stdev": 390.505,
+   "min": 101.073,
+   "max": 869.433,
+   "ci95": 970.146
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 44.209,
+   "stdev": 39.491,
+   "min": 1.644,
+   "max": 79.658,
+   "ci95": 98.109
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 10.635,
+   "stdev": 9.759,
+   "min": 0.686,
+   "max": 20.192,
+   "ci95": 24.244
+  },
+  "memory.village.gpu_mb": {
+   "n": 3,
+   "mean": 34.333,
+   "stdev": 36.95,
+   "min": 13.0,
+   "max": 77.0,
+   "ci95": 91.797
+  },
+  "memory.village.rss_mb": {
+   "n": 3,
+   "mean": 3296.229,
+   "stdev": 296.464,
+   "min": 2956.234,
+   "max": 3500.773,
+   "ci95": 736.517
+  },
+  "tick.village.client_ms": {
+   "n": 3,
+   "mean": 1.23,
+   "stdev": 0.449,
+   "min": 0.897,
+   "max": 1.74,
+   "ci95": 1.114
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 61172.527,
+   "stdev": 17434.762,
+   "min": 46779.931,
+   "max": 80559.429,
+   "ci95": 43313.846
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 599.408,
+   "stdev": 492.96,
+   "min": 64.173,
+   "max": 1034.813,
+   "ci95": 1224.68
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 61.923,
+   "stdev": 56.534,
+   "min": 0.737,
+   "max": 112.221,
+   "ci95": 140.449
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 15.771,
+   "stdev": 14.11,
+   "min": 0.098,
+   "max": 27.463,
+   "ci95": 35.054
+  },
+  "memory.forest.gpu_mb": {
+   "n": 3,
+   "mean": 34.333,
+   "stdev": 36.95,
+   "min": 13.0,
+   "max": 77.0,
+   "ci95": 91.797
+  },
+  "memory.forest.rss_mb": {
+   "n": 3,
+   "mean": 3278.964,
+   "stdev": 301.465,
+   "min": 2947.268,
+   "max": 3536.27,
+   "ci95": 748.941
+  },
+  "tick.forest.client_ms": {
+   "n": 3,
+   "mean": 5.908,
+   "stdev": 8.813,
+   "min": 0.693,
+   "max": 16.084,
+   "ci95": 21.895
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 61762.098,
+   "stdev": 3569.17,
+   "min": 57919.097,
+   "max": 64972.973,
+   "ci95": 8867.026
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 1175.044,
+   "stdev": 131.94,
+   "min": 1093.801,
+   "max": 1327.281,
+   "ci95": 327.785
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 119.758,
+   "stdev": 68.419,
+   "min": 77.252,
+   "max": 198.683,
+   "ci95": 169.976
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 24.224,
+   "stdev": 18.982,
+   "min": 12.308,
+   "max": 46.114,
+   "ci95": 47.159
+  },
+  "memory.ocean.gpu_mb": {
+   "n": 3,
+   "mean": 34.333,
+   "stdev": 36.95,
+   "min": 13.0,
+   "max": 77.0,
+   "ci95": 91.797
+  },
+  "memory.ocean.rss_mb": {
+   "n": 3,
+   "mean": 3275.349,
+   "stdev": 317.864,
+   "min": 2924.113,
+   "max": 3543.23,
+   "ci95": 789.681
+  },
+  "tick.ocean.client_ms": {
+   "n": 3,
+   "mean": 0.654,
+   "stdev": 0.066,
+   "min": 0.579,
+   "max": 0.699,
+   "ci95": 0.163
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 113439.529,
+   "stdev": 64746.162,
+   "min": 55046.887,
+   "max": 183068.386,
+   "ci95": 160851.363
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 485.832,
+   "stdev": 317.254,
+   "min": 121.312,
+   "max": 699.617,
+   "ci95": 788.165
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 28.612,
+   "stdev": 23.334,
+   "min": 2.229,
+   "max": 46.542,
+   "ci95": 57.97
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 4.56,
+   "stdev": 3.408,
+   "min": 0.75,
+   "max": 7.318,
+   "ci95": 8.467
+  },
+  "memory.mountain.gpu_mb": {
+   "n": 3,
+   "mean": 34.333,
+   "stdev": 36.95,
+   "min": 13.0,
+   "max": 77.0,
+   "ci95": 91.797
+  },
+  "memory.mountain.rss_mb": {
+   "n": 3,
+   "mean": 3248.708,
+   "stdev": 480.962,
+   "min": 2700.645,
+   "max": 3600.484,
+   "ci95": 1194.873
+  },
+  "tick.mountain.client_ms": {
+   "n": 3,
+   "mean": 1.832,
+   "stdev": 2.076,
+   "min": 0.618,
+   "max": 4.229,
+   "ci95": 5.157
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 3371.958,
+   "stdev": 280.347,
+   "min": 3059.926,
+   "max": 3602.613,
+   "ci95": 696.476
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 3291.249,
+   "stdev": 316.441,
+   "min": 2935.975,
+   "max": 3542.848,
+   "ci95": 786.147
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 1248,
+   "seconds": 12.348,
+   "avg_fps": 101.073,
+   "low_1pct_fps": 1.644,
+   "low_01pct_fps": 0.686,
+   "p50_ms": 1.225,
+   "p95_ms": 11.161,
+   "p99_ms": 226.597,
+   "p999_ms": 1457.605,
+   "max_ms": 1457.874,
+   "histogram": [
+    548,
+    232,
+    97,
+    118,
+    51,
+    49,
+    24,
+    39,
+    16,
+    17,
+    13,
+    6,
+    3,
+    2,
+    5,
+    3,
+    2,
+    2,
+    4,
+    2,
+    3,
+    8,
+    1,
+    3
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 10435,
+   "seconds": 12.002,
+   "avg_fps": 869.433,
+   "low_1pct_fps": 79.658,
+   "low_01pct_fps": 20.192,
+   "p50_ms": 0.813,
+   "p95_ms": 2.537,
+   "p99_ms": 5.685,
+   "p999_ms": 13.292,
+   "max_ms": 351.251,
+   "histogram": [
+    7598,
+    2071,
+    393,
+    171,
+    55,
+    53,
+    22,
+    24,
+    20,
+    10,
+    9,
+    2,
+    2,
+    1,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 7278,
+   "seconds": 12.0,
+   "avg_fps": 606.495,
+   "low_1pct_fps": 51.326,
+   "low_01pct_fps": 11.026,
+   "p50_ms": 1.105,
+   "p95_ms": 3.854,
+   "p99_ms": 7.067,
+   "p999_ms": 24.484,
+   "max_ms": 443.95,
+   "histogram": [
+    3206,
+    2621,
+    800,
+    360,
+    112,
+    71,
+    34,
+    26,
+    12,
+    13,
+    3,
+    5,
+    2,
+    7,
+    2,
+    1,
+    1,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 975,
+   "seconds": 15.193,
+   "avg_fps": 64.173,
+   "low_1pct_fps": 0.737,
+   "low_01pct_fps": 0.098,
+   "p50_ms": 0.864,
+   "p95_ms": 5.083,
+   "p99_ms": 77.689,
+   "p999_ms": 10225.237,
+   "max_ms": 10225.237,
+   "histogram": [
+    680,
+    99,
+    104,
+    12,
+    30,
+    13,
+    8,
+    4,
+    2,
+    3,
+    2,
+    1,
+    1,
+    3,
+    0,
+    1,
+    0,
+    1,
+    2,
+    3,
+    1,
+    2,
+    1,
+    2
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 8391,
+   "seconds": 12.0,
+   "avg_fps": 699.237,
+   "low_1pct_fps": 72.811,
+   "low_01pct_fps": 19.752,
+   "p50_ms": 1.087,
+   "p95_ms": 2.927,
+   "p99_ms": 5.909,
+   "p999_ms": 15.268,
+   "max_ms": 252.557,
+   "histogram": [
+    3342,
+    3998,
+    656,
+    231,
+    56,
+    26,
+    15,
+    19,
+    12,
+    12,
+    11,
+    6,
+    1,
+    3,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 12418,
+   "seconds": 12.0,
+   "avg_fps": 1034.813,
+   "low_1pct_fps": 112.221,
+   "low_01pct_fps": 27.463,
+   "p50_ms": 0.837,
+   "p95_ms": 1.394,
+   "p99_ms": 3.491,
+   "p999_ms": 13.217,
+   "max_ms": 245.59,
+   "histogram": [
+    11155,
+    1004,
+    100,
+    64,
+    29,
+    16,
+    16,
+    10,
+    2,
+    6,
+    5,
+    3,
+    4,
+    2,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 13126,
+   "seconds": 12.0,
+   "avg_fps": 1093.801,
+   "low_1pct_fps": 77.252,
+   "low_01pct_fps": 12.308,
+   "p50_ms": 0.714,
+   "p95_ms": 1.402,
+   "p99_ms": 2.875,
+   "p999_ms": 12.067,
+   "max_ms": 238.158,
+   "histogram": [
+    11605,
+    1207,
+    191,
+    54,
+    17,
+    11,
+    7,
+    12,
+    4,
+    4,
+    2,
+    3,
+    2,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    2,
+    3,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 15928,
+   "seconds": 12.0,
+   "avg_fps": 1327.281,
+   "low_1pct_fps": 198.683,
+   "low_01pct_fps": 46.114,
+   "p50_ms": 0.67,
+   "p95_ms": 1.172,
+   "p99_ms": 2.111,
+   "p999_ms": 7.067,
+   "max_ms": 193.743,
+   "histogram": [
+    14891,
+    856,
+    102,
+    42,
+    7,
+    6,
+    8,
+    6,
+    0,
+    5,
+    3,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 13249,
+   "seconds": 12.0,
+   "avg_fps": 1104.051,
+   "low_1pct_fps": 83.338,
+   "low_01pct_fps": 14.249,
+   "p50_ms": 0.711,
+   "p95_ms": 1.403,
+   "p99_ms": 3.046,
+   "p999_ms": 10.625,
+   "max_ms": 451.869,
+   "histogram": [
+    11824,
+    1165,
+    124,
+    58,
+    13,
+    16,
+    11,
+    14,
+    7,
+    7,
+    3,
+    2,
+    1,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    1,
+    1,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 1469,
+   "seconds": 12.109,
+   "avg_fps": 121.312,
+   "low_1pct_fps": 2.229,
+   "low_01pct_fps": 0.75,
+   "p50_ms": 2.12,
+   "p95_ms": 13.173,
+   "p99_ms": 125.189,
+   "p999_ms": 727.045,
+   "max_ms": 1939.723,
+   "histogram": [
+    196,
+    440,
+    438,
+    136,
+    50,
+    36,
+    24,
+    25,
+    22,
+    17,
+    17,
+    13,
+    6,
+    11,
+    8,
+    4,
+    1,
+    4,
+    4,
+    4,
+    3,
+    7,
+    2,
+    1
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 8396,
+   "seconds": 12.001,
+   "avg_fps": 699.617,
+   "low_1pct_fps": 46.542,
+   "low_01pct_fps": 7.318,
+   "p50_ms": 1.022,
+   "p95_ms": 2.433,
+   "p99_ms": 5.528,
+   "p999_ms": 13.993,
+   "max_ms": 305.464,
+   "histogram": [
+    3248,
+    4509,
+    361,
+    113,
+    52,
+    37,
+    21,
+    26,
+    14,
+    4,
+    3,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    2,
+    2,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 7639,
+   "seconds": 12.0,
+   "avg_fps": 636.566,
+   "low_1pct_fps": 37.064,
+   "low_01pct_fps": 5.612,
+   "p50_ms": 1.023,
+   "p95_ms": 3.0,
+   "p99_ms": 7.11,
+   "p999_ms": 17.521,
+   "max_ms": 268.877,
+   "histogram": [
+    3051,
+    3794,
+    413,
+    158,
+    66,
+    43,
+    35,
+    21,
+    31,
+    12,
+    3,
+    4,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    4,
+    2,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "vanilla-desktop"
+}
@@ -0,0 +1,771 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-11-04T12:54:29Z",
+ "app": {
+  "name": "minecraft",
+  "version": "26.3",
+  "mods": [
+   {
+    "name": "fabric-loader",
+    "version": "0.19.5"
+   }
+  ]
+ },
+ "hardware": {
+  "os": "macos",
+  "arch": "aarch64",
+  "cpu_threads": 14,
+  "os_version": "27.0.1",
+  "cpu": "Apple M4 Pro",
+  "ram_mb": 65536,
+  "gpu": {
+   "name": "Apple M4 Pro",
+   "vendor": "Apple",
+   "driver": "4.1 Metal - 91.7",
+   "backend": "opengl",
+   "kind": ""
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 12,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "load_avg_1m": 17.628,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 12652.182,
+   "stdev": 3231.342,
+   "min": 9526.004,
+   "max": 15979.309,
+   "ci95": 8027.746
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 31329.516,
+   "stdev": 10016.129,
+   "min": 20777.004,
+   "max": 40705.309,
+   "ci95": 24883.451
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 12623.084,
+   "stdev": 4958.724,
+   "min": 7251.986,
+   "max": 17026.894,
+   "ci95": 12319.147
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 92.729,
+   "stdev": 58.527,
+   "min": 28.713,
+   "max": 143.496,
+   "ci95": 145.402
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 16.52,
+   "stdev": 10.949,
+   "min": 4.001,
+   "max": 24.308,
+   "ci95": 27.2
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 11.515,
+   "stdev": 7.155,
+   "min": 3.549,
+   "max": 17.394,
+   "ci95": 17.774
+  },
+  "memory.village.rss_mb": {
+   "n": 3,
+   "mean": 1834.469,
+   "stdev": 329.198,
+   "min": 1455.688,
+   "max": 2051.516,
+   "ci95": 817.839
+  },
+  "tick.village.client_ms": {
+   "n": 3,
+   "mean": 1.903,
+   "stdev": 1.114,
+   "min": 1.131,
+   "max": 3.18,
+   "ci95": 2.767
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 14590.694,
+   "stdev": 3260.615,
+   "min": 10942.613,
+   "max": 17221.108,
+   "ci95": 8100.47
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 106.817,
+   "stdev": 104.558,
+   "min": 43.857,
+   "max": 227.513,
+   "ci95": 259.759
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 23.0,
+   "stdev": 26.394,
+   "min": 7.338,
+   "max": 53.473,
+   "ci95": 65.57
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 14.841,
+   "stdev": 15.773,
+   "min": 5.157,
+   "max": 33.042,
+   "ci95": 39.186
+  },
+  "memory.forest.rss_mb": {
+   "n": 3,
+   "mean": 1814.245,
+   "stdev": 154.974,
+   "min": 1635.453,
+   "max": 1910.125,
+   "ci95": 385.007
+  },
+  "tick.forest.client_ms": {
+   "n": 3,
+   "mean": 1.452,
+   "stdev": 0.542,
+   "min": 0.826,
+   "max": 1.777,
+   "ci95": 1.346
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 13309.049,
+   "stdev": 8088.157,
+   "min": 6394.403,
+   "max": 22203.194,
+   "ci95": 20093.716
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 164.405,
+   "stdev": 141.4,
+   "min": 62.162,
+   "max": 325.77,
+   "ci95": 351.285
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 36.242,
+   "stdev": 37.051,
+   "min": 14.736,
+   "max": 79.024,
+   "ci95": 92.047
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 20.898,
+   "stdev": 17.899,
+   "min": 8.855,
+   "max": 41.466,
+   "ci95": 44.468
+  },
+  "memory.ocean.rss_mb": {
+   "n": 3,
+   "mean": 1724.453,
+   "stdev": 347.692,
+   "min": 1323.5,
+   "max": 1942.734,
+   "ci95": 863.784
+  },
+  "tick.ocean.client_ms": {
+   "n": 3,
+   "mean": 0.866,
+   "stdev": 0.248,
+   "min": 0.58,
+   "max": 1.03,
+   "ci95": 0.617
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 17989.43,
+   "stdev": 3969.295,
+   "min": 13444.423,
+   "max": 20774.261,
+   "ci95": 9861.07
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 162.084,
+   "stdev": 160.057,
+   "min": 68.44,
+   "max": 346.896,
+   "ci95": 397.635
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 33.74,
+   "stdev": 36.146,
+   "min": 11.158,
+   "max": 75.429,
+   "ci95": 89.798
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 17.194,
+   "stdev": 14.232,
+   "min": 7.903,
+   "max": 33.579,
+   "ci95": 35.357
+  },
+  "memory.mountain.rss_mb": {
+   "n": 3,
+   "mean": 1977.602,
+   "stdev": 108.627,
+   "min": 1872.516,
+   "max": 2089.453,
+   "ci95": 269.866
+  },
+  "tick.mountain.client_ms": {
+   "n": 3,
+   "mean": 0.772,
+   "stdev": 0.332,
+   "min": 0.463,
+   "max": 1.123,
+   "ci95": 0.825
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 2135.313,
+   "stdev": 54.617,
+   "min": 2072.344,
+   "max": 2169.828,
+   "ci95": 135.686
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 1836.44,
+   "stdev": 223.694,
+   "min": 1578.141,
+   "max": 1965.781,
+   "ci95": 555.732
+  },
+  "memory.footprint_peak_mb": {
+   "n": 3,
+   "mean": 3253.456,
+   "stdev": 68.323,
+   "min": 3178.409,
+   "max": 3312.05,
+   "ci95": 169.737
+  },
+  "memory.footprint_steady_mb": {
+   "n": 3,
+   "mean": 3144.363,
+   "stdev": 69.868,
+   "min": 3069.394,
+   "max": 3207.66,
+   "ci95": 173.576
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 1272,
+   "seconds": 12.002,
+   "avg_fps": 105.979,
+   "low_1pct_fps": 21.25,
+   "low_01pct_fps": 17.394,
+   "p50_ms": 7.527,
+   "p95_ms": 22.34,
+   "p99_ms": 40.461,
+   "p999_ms": 54.28,
+   "max_ms": 60.7,
+   "histogram": [
+    0,
+    0,
+    0,
+    56,
+    161,
+    170,
+    180,
+    167,
+    184,
+    118,
+    71,
+    61,
+    26,
+    25,
+    28,
+    12,
+    10,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 1723,
+   "seconds": 12.007,
+   "avg_fps": 143.496,
+   "low_1pct_fps": 24.308,
+   "low_01pct_fps": 13.602,
+   "p50_ms": 5.317,
+   "p95_ms": 16.181,
+   "p99_ms": 29.771,
+   "p999_ms": 56.832,
+   "max_ms": 90.209,
+   "histogram": [
+    0,
+    0,
+    63,
+    413,
+    271,
+    273,
+    185,
+    148,
+    112,
+    89,
+    47,
+    43,
+    28,
+    22,
+    18,
+    4,
+    5,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 346,
+   "seconds": 12.05,
+   "avg_fps": 28.713,
+   "low_1pct_fps": 4.001,
+   "low_01pct_fps": 3.549,
+   "p50_ms": 23.684,
+   "p95_ms": 110.057,
+   "p99_ms": 225.236,
+   "p999_ms": 281.776,
+   "max_ms": 281.776,
+   "histogram": [
+    0,
+    0,
+    0,
+    4,
+    8,
+    6,
+    6,
+    12,
+    21,
+    20,
+    23,
+    25,
+    24,
+    32,
+    50,
+    28,
+    24,
+    27,
+    17,
+    11,
+    6,
+    2,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 589,
+   "seconds": 12.001,
+   "avg_fps": 49.081,
+   "low_1pct_fps": 8.19,
+   "low_01pct_fps": 6.325,
+   "p50_ms": 15.443,
+   "p95_ms": 53.004,
+   "p99_ms": 94.69,
+   "p999_ms": 158.114,
+   "max_ms": 158.114,
+   "histogram": [
+    0,
+    0,
+    0,
+    2,
+    7,
+    20,
+    30,
+    46,
+    53,
+    48,
+    56,
+    62,
+    61,
+    66,
+    63,
+    18,
+    22,
+    20,
+    10,
+    4,
+    1,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 2731,
+   "seconds": 12.004,
+   "avg_fps": 227.513,
+   "low_1pct_fps": 53.473,
+   "low_01pct_fps": 33.042,
+   "p50_ms": 3.801,
+   "p95_ms": 7.955,
+   "p99_ms": 14.177,
+   "p999_ms": 24.479,
+   "max_ms": 38.218,
+   "histogram": [
+    0,
+    0,
+    526,
+    1157,
+    432,
+    257,
+    151,
+    88,
+    46,
+    32,
+    13,
+    15,
+    6,
+    6,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 527,
+   "seconds": 12.016,
+   "avg_fps": 43.857,
+   "low_1pct_fps": 7.338,
+   "low_01pct_fps": 5.157,
+   "p50_ms": 16.784,
+   "p95_ms": 57.353,
+   "p99_ms": 111.984,
+   "p999_ms": 193.905,
+   "max_ms": 193.905,
+   "histogram": [
+    0,
+    0,
+    0,
+    1,
+    2,
+    9,
+    16,
+    29,
+    40,
+    61,
+    50,
+    54,
+    52,
+    62,
+    57,
+    35,
+    28,
+    11,
+    13,
+    5,
+    2,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 746,
+   "seconds": 12.001,
+   "avg_fps": 62.162,
+   "low_1pct_fps": 14.965,
+   "low_01pct_fps": 12.372,
+   "p50_ms": 13.76,
+   "p95_ms": 35.144,
+   "p99_ms": 57.63,
+   "p999_ms": 80.827,
+   "max_ms": 80.827,
+   "histogram": [
+    0,
+    0,
+    2,
+    13,
+    12,
+    41,
+    37,
+    53,
+    67,
+    82,
+    80,
+    99,
+    82,
+    76,
+    58,
+    17,
+    11,
+    12,
+    4,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 3910,
+   "seconds": 12.002,
+   "avg_fps": 325.77,
+   "low_1pct_fps": 79.024,
+   "low_01pct_fps": 41.466,
+   "p50_ms": 2.685,
+   "p95_ms": 5.125,
+   "p99_ms": 8.342,
+   "p999_ms": 20.782,
+   "max_ms": 30.571,
+   "histogram": [
+    0,
+    78,
+    2526,
+    892,
+    203,
+    95,
+    49,
+    27,
+    13,
+    11,
+    7,
+    3,
+    2,
+    3,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 1268,
+   "seconds": 12.044,
+   "avg_fps": 105.282,
+   "low_1pct_fps": 14.736,
+   "low_01pct_fps": 8.855,
+   "p50_ms": 6.542,
+   "p95_ms": 25.245,
+   "p99_ms": 50.465,
+   "p999_ms": 79.065,
+   "max_ms": 146.809,
+   "histogram": [
+    0,
+    0,
+    4,
+    171,
+    190,
+    169,
+    167,
+    133,
+    105,
+    93,
+    53,
+    43,
+    35,
+    41,
+    26,
+    13,
+    11,
+    10,
+    3,
+    1,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 822,
+   "seconds": 12.011,
+   "avg_fps": 68.44,
+   "low_1pct_fps": 14.632,
+   "low_01pct_fps": 10.101,
+   "p50_ms": 11.396,
+   "p95_ms": 35.387,
+   "p99_ms": 55.24,
+   "p999_ms": 99.005,
+   "max_ms": 99.005,
+   "histogram": [
+    0,
+    0,
+    0,
+    10,
+    42,
+    62,
+    55,
+    86,
+    89,
+    97,
+    64,
+    73,
+    74,
+    72,
+    48,
+    21,
+    17,
+    8,
+    4,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 4165,
+   "seconds": 12.006,
+   "avg_fps": 346.896,
+   "low_1pct_fps": 75.429,
+   "low_01pct_fps": 33.579,
+   "p50_ms": 2.541,
+   "p95_ms": 4.838,
+   "p99_ms": 7.998,
+   "p999_ms": 20.209,
+   "max_ms": 53.577,
+   "histogram": [
+    0,
+    640,
+    2307,
+    855,
+    178,
+    93,
+    34,
+    22,
+    15,
+    3,
+    3,
+    8,
+    2,
+    2,
+    2,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 851,
+   "seconds": 12.0,
+   "avg_fps": 70.916,
+   "low_1pct_fps": 11.158,
+   "low_01pct_fps": 7.903,
+   "p50_ms": 10.128,
+   "p95_ms": 36.498,
+   "p99_ms": 68.434,
+   "p999_ms": 126.541,
+   "max_ms": 126.541,
+   "histogram": [
+    0,
+    0,
+    0,
+    38,
+    61,
+    87,
+    76,
+    69,
+    84,
+    100,
+    63,
+    53,
+    68,
+    53,
+    48,
+    15,
+    9,
+    16,
+    9,
+    2,
+    0,
+    0,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "vanilla-macmini"
+}
@@ -0,0 +1,771 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-11-04T13:08:37Z",
+ "app": {
+  "name": "minecraft",
+  "version": "26.3",
+  "mods": [
+   {
+    "name": "fabric-loader",
+    "version": "0.19.5"
+   }
+  ]
+ },
+ "hardware": {
+  "os": "macos",
+  "arch": "aarch64",
+  "cpu_threads": 14,
+  "os_version": "27.0.1",
+  "cpu": "Apple M4 Pro",
+  "ram_mb": 65536,
+  "gpu": {
+   "name": "Apple M4 Pro",
+   "vendor": "Apple",
+   "driver": "4.1 Metal - 91.7",
+   "backend": "opengl",
+   "kind": ""
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 32,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "load_avg_1m": 18.159,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 8607.88,
+   "stdev": 949.596,
+   "min": 8010.323,
+   "max": 9702.854,
+   "ci95": 2359.119
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 44182.88,
+   "stdev": 4031.933,
+   "min": 40172.323,
+   "max": 48235.854,
+   "ci95": 10016.685
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 17227.171,
+   "stdev": 5351.234,
+   "min": 13892.279,
+   "max": 23399.566,
+   "ci95": 13294.274
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 76.237,
+   "stdev": 45.661,
+   "min": 28.922,
+   "max": 120.041,
+   "ci95": 113.437
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 17.319,
+   "stdev": 12.99,
+   "min": 5.593,
+   "max": 31.283,
+   "ci95": 32.272
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 12.642,
+   "stdev": 9.463,
+   "min": 4.308,
+   "max": 22.93,
+   "ci95": 23.51
+  },
+  "memory.village.rss_mb": {
+   "n": 3,
+   "mean": 2674.987,
+   "stdev": 30.71,
+   "min": 2641.352,
+   "max": 2701.531,
+   "ci95": 76.294
+  },
+  "tick.village.client_ms": {
+   "n": 3,
+   "mean": 1.341,
+   "stdev": 0.407,
+   "min": 0.924,
+   "max": 1.737,
+   "ci95": 1.012
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 34112.389,
+   "stdev": 19305.487,
+   "min": 22633.094,
+   "max": 56401.09,
+   "ci95": 47961.36
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 72.848,
+   "stdev": 51.859,
+   "min": 18.307,
+   "max": 121.528,
+   "ci95": 128.837
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 22.096,
+   "stdev": 20.299,
+   "min": 3.973,
+   "max": 44.03,
+   "ci95": 50.429
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 16.093,
+   "stdev": 14.608,
+   "min": 3.688,
+   "max": 32.194,
+   "ci95": 36.291
+  },
+  "memory.forest.rss_mb": {
+   "n": 3,
+   "mean": 2519.729,
+   "stdev": 82.097,
+   "min": 2426.297,
+   "max": 2580.328,
+   "ci95": 203.957
+  },
+  "tick.forest.client_ms": {
+   "n": 3,
+   "mean": 1.115,
+   "stdev": 0.411,
+   "min": 0.726,
+   "max": 1.545,
+   "ci95": 1.02
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 19066.516,
+   "stdev": 9372.33,
+   "min": 13163.781,
+   "max": 29873.383,
+   "ci95": 23284.039
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 69.735,
+   "stdev": 46.656,
+   "min": 16.524,
+   "max": 103.635,
+   "ci95": 115.909
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 17.636,
+   "stdev": 13.616,
+   "min": 3.179,
+   "max": 30.217,
+   "ci95": 33.827
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 12.115,
+   "stdev": 10.798,
+   "min": 2.584,
+   "max": 23.842,
+   "ci95": 26.825
+  },
+  "memory.ocean.rss_mb": {
+   "n": 3,
+   "mean": 2557.143,
+   "stdev": 84.375,
+   "min": 2463.781,
+   "max": 2627.945,
+   "ci95": 209.616
+  },
+  "tick.ocean.client_ms": {
+   "n": 3,
+   "mean": 1.056,
+   "stdev": 0.233,
+   "min": 0.815,
+   "max": 1.281,
+   "ci95": 0.58
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 62214.712,
+   "stdev": 4884.13,
+   "min": 58937.045,
+   "max": 67828.14,
+   "ci95": 12133.83
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 51.809,
+   "stdev": 7.118,
+   "min": 45.235,
+   "max": 59.369,
+   "ci95": 17.685
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 6.336,
+   "stdev": 1.097,
+   "min": 5.545,
+   "max": 7.588,
+   "ci95": 2.725
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 3.458,
+   "stdev": 0.756,
+   "min": 2.827,
+   "max": 4.296,
+   "ci95": 1.878
+  },
+  "memory.mountain.rss_mb": {
+   "n": 3,
+   "mean": 2604.227,
+   "stdev": 15.043,
+   "min": 2588.234,
+   "max": 2618.094,
+   "ci95": 37.371
+  },
+  "tick.mountain.client_ms": {
+   "n": 3,
+   "mean": 0.957,
+   "stdev": 0.03,
+   "min": 0.926,
+   "max": 0.985,
+   "ci95": 0.074
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 2731.016,
+   "stdev": 56.767,
+   "min": 2688.516,
+   "max": 2795.484,
+   "ci95": 141.03
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 2577.339,
+   "stdev": 77.295,
+   "min": 2488.203,
+   "max": 2625.875,
+   "ci95": 192.028
+  },
+  "memory.footprint_peak_mb": {
+   "n": 3,
+   "mean": 4612.571,
+   "stdev": 20.245,
+   "min": 4595.363,
+   "max": 4634.879,
+   "ci95": 50.296
+  },
+  "memory.footprint_steady_mb": {
+   "n": 3,
+   "mean": 4271.925,
+   "stdev": 26.308,
+   "min": 4246.207,
+   "max": 4298.785,
+   "ci95": 65.357
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 349,
+   "seconds": 12.067,
+   "avg_fps": 28.922,
+   "low_1pct_fps": 5.593,
+   "low_01pct_fps": 4.308,
+   "p50_ms": 24.684,
+   "p95_ms": 92.764,
+   "p99_ms": 150.338,
+   "p999_ms": 232.136,
+   "max_ms": 232.136,
+   "histogram": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    2,
+    3,
+    13,
+    17,
+    26,
+    31,
+    40,
+    46,
+    50,
+    32,
+    25,
+    20,
+    30,
+    10,
+    4,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 1441,
+   "seconds": 12.004,
+   "avg_fps": 120.041,
+   "low_1pct_fps": 31.283,
+   "low_01pct_fps": 22.93,
+   "p50_ms": 7.267,
+   "p95_ms": 13.622,
+   "p99_ms": 23.449,
+   "p999_ms": 42.564,
+   "max_ms": 44.657,
+   "histogram": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    64,
+    543,
+    397,
+    218,
+    100,
+    54,
+    24,
+    20,
+    7,
+    7,
+    5,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 958,
+   "seconds": 12.013,
+   "avg_fps": 79.749,
+   "low_1pct_fps": 15.082,
+   "low_01pct_fps": 10.689,
+   "p50_ms": 9.138,
+   "p95_ms": 28.848,
+   "p99_ms": 52.247,
+   "p999_ms": 93.55,
+   "max_ms": 93.55,
+   "histogram": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    19,
+    144,
+    232,
+    148,
+    111,
+    64,
+    56,
+    59,
+    57,
+    32,
+    17,
+    9,
+    6,
+    4,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 220,
+   "seconds": 12.017,
+   "avg_fps": 18.307,
+   "low_1pct_fps": 3.973,
+   "low_01pct_fps": 3.688,
+   "p50_ms": 40.635,
+   "p95_ms": 157.363,
+   "p99_ms": 235.253,
+   "p999_ms": 271.153,
+   "max_ms": 271.153,
+   "histogram": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    3,
+    6,
+    14,
+    17,
+    25,
+    25,
+    17,
+    27,
+    33,
+    24,
+    16,
+    11,
+    1,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 1459,
+   "seconds": 12.005,
+   "avg_fps": 121.528,
+   "low_1pct_fps": 44.03,
+   "low_01pct_fps": 32.194,
+   "p50_ms": 7.381,
+   "p95_ms": 12.386,
+   "p99_ms": 18.354,
+   "p999_ms": 29.428,
+   "max_ms": 32.695,
+   "histogram": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    357,
+    642,
+    300,
+    80,
+    28,
+    28,
+    14,
+    7,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 945,
+   "seconds": 12.006,
+   "avg_fps": 78.709,
+   "low_1pct_fps": 18.284,
+   "low_01pct_fps": 12.397,
+   "p50_ms": 9.554,
+   "p95_ms": 27.657,
+   "p99_ms": 43.253,
+   "p999_ms": 80.663,
+   "max_ms": 80.663,
+   "histogram": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    18,
+    304,
+    191,
+    119,
+    67,
+    59,
+    53,
+    70,
+    34,
+    15,
+    10,
+    3,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 201,
+   "seconds": 12.164,
+   "avg_fps": 16.524,
+   "low_1pct_fps": 3.179,
+   "low_01pct_fps": 2.584,
+   "p50_ms": 44.933,
+   "p95_ms": 155.019,
+   "p99_ms": 263.919,
+   "p999_ms": 387.044,
+   "max_ms": 387.044,
+   "histogram": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    2,
+    4,
+    7,
+    20,
+    8,
+    29,
+    18,
+    25,
+    29,
+    29,
+    17,
+    8,
+    4,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 1244,
+   "seconds": 12.004,
+   "avg_fps": 103.635,
+   "low_1pct_fps": 30.217,
+   "low_01pct_fps": 23.842,
+   "p50_ms": 8.349,
+   "p95_ms": 17.445,
+   "p99_ms": 28.276,
+   "p999_ms": 38.037,
+   "max_ms": 45.85,
+   "histogram": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    162,
+    453,
+    312,
+    129,
+    71,
+    47,
+    32,
+    18,
+    16,
+    3,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 1069,
+   "seconds": 12.005,
+   "avg_fps": 89.047,
+   "low_1pct_fps": 19.512,
+   "low_01pct_fps": 9.92,
+   "p50_ms": 9.541,
+   "p95_ms": 20.819,
+   "p99_ms": 31.409,
+   "p999_ms": 99.668,
+   "max_ms": 101.942,
+   "histogram": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    64,
+    266,
+    283,
+    160,
+    112,
+    74,
+    51,
+    33,
+    17,
+    4,
+    1,
+    2,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 551,
+   "seconds": 12.181,
+   "avg_fps": 45.235,
+   "low_1pct_fps": 5.545,
+   "low_01pct_fps": 3.252,
+   "p50_ms": 14.921,
+   "p95_ms": 50.78,
+   "p99_ms": 105.154,
+   "p999_ms": 307.476,
+   "max_ms": 307.476,
+   "histogram": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    42,
+    137,
+    72,
+    58,
+    50,
+    47,
+    57,
+    39,
+    20,
+    15,
+    8,
+    3,
+    2,
+    1,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 718,
+   "seconds": 12.094,
+   "avg_fps": 59.369,
+   "low_1pct_fps": 7.588,
+   "low_01pct_fps": 4.296,
+   "p50_ms": 12.178,
+   "p95_ms": 38.273,
+   "p99_ms": 65.694,
+   "p999_ms": 232.789,
+   "max_ms": 232.789,
+   "histogram": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    140,
+    202,
+    115,
+    72,
+    48,
+    47,
+    43,
+    19,
+    19,
+    6,
+    4,
+    0,
+    3,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 610,
+   "seconds": 12.003,
+   "avg_fps": 50.822,
+   "low_1pct_fps": 5.875,
+   "low_01pct_fps": 2.827,
+   "p50_ms": 13.894,
+   "p95_ms": 44.208,
+   "p99_ms": 75.023,
+   "p999_ms": 353.686,
+   "max_ms": 353.686,
+   "histogram": [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    67,
+    115,
+    125,
+    88,
+    55,
+    54,
+    43,
+    25,
+    13,
+    15,
+    7,
+    0,
+    1,
+    2,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "vanilla-macmini"
+}
@@ -0,0 +1,5 @@
+# `keys.contains(&KeyCode::ShiftLeft)` reads a mapping by its default key: ask by `Action`, so the
+# mapping is named and every device that can hold it counts.
+disallowed-methods = [
+    { path = "horizon_client_input::held::HeldKeys::contains", reason = "use `held(Action::..)`, or `raw` for a key that is no mapping's default", allow-invalid = true },
+]
@@ -93,7 +93,7 @@ pub fn kind_of(path: &Path) -> Option<Kind> {
        "hmod" => Some(Kind::Mod),
        "hnmod" => Some(Kind::NativeMod),
        "hpack" => Some(Kind::Modpack),
-        "zip" => Some(Kind::ResourcePack),
+        "zip" => Some(horizon_mods::index::zip_kind(path)),
        "hshader" => Some(Kind::Shader),
        _ => None,
    }
@@ -108,6 +108,16 @@ impl<T> CompiledChoices<T> {
            multipart: self.multipart.iter().map(|c| c.map(&mut f)).collect(),
        }
    }
+    /// A variant that needs no random selection and produces exactly one model.
+    pub fn single_variant(&self, selected: &SelectedModels) -> Option<&T> {
+        let SelectedModels::Variant(index) = selected else {
+            return None;
+        };
+        match self.variants.get(*index)? {
+            Choice::Single(value) => Some(value),
+            Choice::Weighted { .. } => None,
+        }
+    }
    /// The variant `particleMaterial` comes from: the first entry of a weighted
    /// list (`WeightedVariants`) and, for a multipart root, of its first
    /// selector whether or not that selector applies (`MultiPartModel`).
@@ -90,6 +90,9 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
  --seed N               default 12345
  --explore-speed B      blocks a second an explore bot flies; default 22 (as fast as chunks come)
  --pvp B                fight bots also attack each other (true or false); default true
+  --crits                fight bots swing at a sword's full strength (every 13 ticks) and jump into every
+                         other swing, landing it while falling: a critical hit, then a sweep from the
+                         ground (give them swords); for PvP benches (crit and sweep particles)
  --name PREFIX          bot names: PREFIX0, PREFIX1...; default Bot
  --brand B              the client brand sent in configuration (minecraft:brand); default none
  --height H             blocks above spawn the bots fly at (walk, explore, idle); default 24
@@ -165,6 +168,8 @@ struct Options {
    attack_after: f64,
    attack_rounds: u32,
    no_swing: bool,
+    /// --crits: fight bots alternate jumped critical hits and sweeps at a sword's cooldown.
+    crits: bool,
    flood: usize,
    no_read: bool,
    no_loaded: bool,
@@ -202,6 +207,7 @@ fn options() -> Result<Options, String> {
        attack_after: 5.0,
        attack_rounds: u32::MAX,
        no_swing: false,
+        crits: false,
        flood: 100,
        no_read: false,
        no_loaded: false,
@@ -230,6 +236,10 @@ fn options() -> Result<Options, String> {
            o.no_swing = true;
            continue;
        }
+        if arg == "--crits" {
+            o.crits = true;
+            continue;
+        }
        if arg == "--no-loaded" {
            o.no_loaded = true;
            continue;
@@ -532,11 +542,84 @@ fn distance(a: [f64; 3], b: [f64; 3]) -> f64 {
    ((a[0] - b[0]).powi(2) + (a[1] - b[1]).powi(2) + (a[2] - b[2]).powi(2)).sqrt()
 }

+/// A sword's attack speed is 1.6 a second: full strength 20 / 1.6 = 12.5 ticks after a swing.
+const SWORD_COOLDOWN_TICKS: u32 = 13;
+/// `LivingEntity.getJumpPower`: a jump's first upward motion, in blocks a tick.
+const JUMP_POWER: f64 = 0.42;
+
+/// `--crits`: a fight bot that swings at a sword's full strength and jumps into every other swing, so
+/// it lands while falling (`Player.attack`'s critical hit: falling, not on the ground, full strength),
+/// and the next one from the ground (a sweep: on the ground, full strength, a sword).
+#[derive(Default)]
+struct Crits {
+    /// Vertical motion while in the air (`LivingEntity.travel`: minus 0.08 a tick, times 0.98).
+    jump: Option<f64>,
+    ground: f64,
+    /// The next swing is the jumped one.
+    crit_next: bool,
+}
+
+impl Crits {
+    fn airborne(&self) -> bool {
+        self.jump.is_some()
+    }
+
+    /// One tick: walk up to the target and, with a full cooldown, strike; jump ahead of a crit's swing.
+    fn tick(
+        &mut self,
+        pos: &mut [f64; 3],
+        target: (i32, [f64; 3]),
+        since: &mut u32,
+    ) -> Option<i32> {
+        if let Some(v) = self.jump {
+            pos[1] += v;
+            if pos[1] <= self.ground {
+                pos[1] = self.ground;
+                self.jump = None;
+            } else {
+                self.jump = Some((v - 0.08) * 0.98);
+            }
+        } else {
+            self.ground = pos[1];
+            // A jump takes 6 ticks to its top: start it so the cooldown ends on the way down.
+            if self.crit_next && *since + 8 >= SWORD_COOLDOWN_TICKS {
+                self.jump = Some(JUMP_POWER);
+            }
+        }
+        let falling = self.jump.is_some_and(|v| v < 0.0);
+        if self.crit_next && !falling {
+            *since = since.saturating_add(1);
+            fight_step(pos, target.1);
+            return None;
+        }
+        let hit = fight_tick(pos, target, since, SWORD_COOLDOWN_TICKS);
+        if hit.is_some() {
+            self.crit_next = !self.crit_next;
+        }
+        hit
+    }
+}
+
 /// One tick of a fighting bot with a target: walk up to it, and strike once the cooldown is over.
 /// Returns the entity to attack. `since_attack` counts ticks since the last swing.
-fn fight_tick(pos: &mut [f64; 3], target: (i32, [f64; 3]), since_attack: &mut u32) -> Option<i32> {
+fn fight_tick(
+    pos: &mut [f64; 3],
+    target: (i32, [f64; 3]),
+    since_attack: &mut u32,
+    cooldown: u32,
+) -> Option<i32> {
    *since_attack = since_attack.saturating_add(1);
    let (id, at) = target;
+    fight_step(pos, at);
+    if *since_attack >= cooldown && distance(*pos, at) <= ATTACK_REACH {
+        *since_attack = 0;
+        return Some(id);
+    }
+    None
+}
+
+/// Walk toward `at`, stopping `CLOSE_IN` short of it.
+fn fight_step(pos: &mut [f64; 3], at: [f64; 3]) {
    let (dx, dz) = (at[0] - pos[0], at[2] - pos[2]);
    let horizontal = dx.hypot(dz);
    if horizontal > CLOSE_IN {
@@ -544,11 +627,6 @@ fn fight_tick(pos: &mut [f64; 3], target: (i32, [f64; 3]), since_attack: &mut u3
        pos[0] += dx / horizontal * step;
        pos[2] += dz / horizontal * step;
    }
-    if *since_attack >= ATTACK_COOLDOWN_TICKS && distance(*pos, at) <= ATTACK_REACH {
-        *since_attack = 0;
-        return Some(id);
-    }
-    None
 }

 /// One tick of walking to random points around the spawn, at sprint speed (5.6 blocks a second).
@@ -1124,6 +1202,7 @@ fn run_bot(
        spawn[1] + o.height
    };
    let mut since_attack = ATTACK_COOLDOWN_TICKS;
+    let mut crits = Crits::default();
    let heading = random.unit() * std::f64::consts::TAU;
    let mut target = pos;
    let mut next = Instant::now();
@@ -1181,11 +1260,16 @@ fn run_bot(
                Behaviour::Fight => {
                    let near = lock(&bot.entities).nearest(pos, o.pvp, &bots);
                    if let Some(near) = near {
-                        if let Some(victim) = fight_tick(&mut pos, near, &mut since_attack) {
+                        let hit = if o.crits {
+                            crits.tick(&mut pos, near, &mut since_attack)
+                        } else {
+                            fight_tick(&mut pos, near, &mut since_attack, ATTACK_COOLDOWN_TICKS)
+                        };
+                        if let Some(victim) = hit {
                            // The client sends the attack, then swings the arm.
                            let sent = send(
                                play::Serverbound::Attack(play::Attack { id: victim }).encode(),
-                            ) && send(raw(sb::PUNCH, |w| w.varint(0)));
+                            ) && send(play::Serverbound::Punch(Empty).encode());
                            if sent {
                                bot.attacks.fetch_add(1, Ordering::Relaxed);
                            }
@@ -1300,9 +1384,10 @@ fn run_bot(
                x: pos[0],
                y: pos[1],
                z: pos[2],
-                // Fight bots stand on the ground; the others fly.
+                // Fight bots stand on the ground (but in a --crits jump); the others fly.
                flags: u8::from(
-                    matches!(behaviour, Behaviour::Fight | Behaviour::Stand) || o.ground,
+                    (matches!(behaviour, Behaviour::Fight | Behaviour::Stand) && !crits.airborne())
+                        || o.ground,
                ),
            })
            .encode(),
@@ -1600,7 +1685,9 @@ mod tests {
        let target = (3, [1.0, 64.0, 0.0]);
        let mut since = ATTACK_COOLDOWN_TICKS;
        let hits: Vec<u32> = (0..40)
-            .filter_map(|tick| fight_tick(&mut pos, target, &mut since).map(|_| tick))
+            .filter_map(|tick| {
+                fight_tick(&mut pos, target, &mut since, ATTACK_COOLDOWN_TICKS).map(|_| tick)
+            })
            .collect();
        assert_eq!(hits[0], 0, "a bot in reach strikes at once");
        assert!(
@@ -1617,7 +1704,7 @@ mod tests {
        let mut since = ATTACK_COOLDOWN_TICKS;
        let mut first = None;
        for tick in 0..100 {
-            if fight_tick(&mut pos, target, &mut since).is_some() {
+            if fight_tick(&mut pos, target, &mut since, ATTACK_COOLDOWN_TICKS).is_some() {
                first = Some(tick);
                break;
            }
@@ -1627,6 +1714,43 @@ mod tests {
        assert!(pos[0] < 10.0 - CLOSE_IN + 1e-9);
    }

+    #[test]
+    fn crits_alternate_a_falling_swing_and_a_grounded_one() {
+        let mut pos = [0.0, 64.0, 0.0];
+        let target = (3, [1.0, 64.0, 0.0]);
+        let (mut since, mut crits) = (SWORD_COOLDOWN_TICKS, Crits::default());
+        let mut last_y = pos[1];
+        let mut hits = Vec::new();
+        for tick in 0..120u32 {
+            let hit = crits.tick(&mut pos, target, &mut since);
+            if hit.is_some() {
+                hits.push((tick, crits_state(pos[1], last_y)));
+            }
+            last_y = pos[1];
+        }
+        assert!(hits.len() >= 6, "{hits:?}");
+        for (i, w) in hits.windows(2).enumerate() {
+            assert!(
+                w[1].0 - w[0].0 >= SWORD_COOLDOWN_TICKS,
+                "full strength each time: {hits:?}"
+            );
+            assert_ne!(w[0].1, w[1].1, "swing {i} and the next alternate: {hits:?}");
+        }
+        // A crit lands in the air, on the way down; a sweep from the ground.
+        assert!(hits.iter().any(|h| h.1 == "falling") && hits.iter().any(|h| h.1 == "ground"));
+        assert!(pos[1] >= 64.0);
+    }
+
+    fn crits_state(y: f64, before: f64) -> &'static str {
+        if y == 64.0 {
+            "ground"
+        } else if y < before {
+            "falling"
+        } else {
+            "rising"
+        }
+    }
+
    #[test]
    fn percentiles_use_nearest_rank() {
        assert_eq!(percentile(&[], 50), 0);
@@ -489,15 +489,36 @@ pub fn parse_duration(text: &str) -> Option<i64> {
    (count > 0).then(|| count.checked_mul(unit)).flatten()
 }

-/// `millis` for players, rounded up: minutes up to an hour, hours up to two days, then days.
-pub fn duration_text(millis: i64) -> String {
-    let up = |unit: i64| (millis + unit - 1) / unit;
-    let (count, unit) = if millis <= 60 * MINUTE {
-        (up(MINUTE), "minute")
+/// The unit used when presenting a moderation duration to a player.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DurationUnit {
+    Minute,
+    Hour,
+    Day,
+}
+
+/// A duration's rounded count and unit, shared by logs and translated replies.
+pub fn duration_parts(millis: i64) -> (i64, DurationUnit) {
+    let (unit, kind) = if millis <= 60 * MINUTE {
+        (MINUTE, DurationUnit::Minute)
    } else if millis <= 48 * 60 * MINUTE {
-        (up(60 * MINUTE), "hour")
+        (60 * MINUTE, DurationUnit::Hour)
    } else {
-        (up(24 * 60 * MINUTE), "day")
+        (24 * 60 * MINUTE, DurationUnit::Day)
+    };
+    (
+        millis.div_euclid(unit) + i64::from(millis.rem_euclid(unit) > 0),
+        kind,
+    )
+}
+
+/// `millis` for logs, rounded up: minutes up to an hour, hours up to two days, then days.
+pub fn duration_text(millis: i64) -> String {
+    let (count, unit) = duration_parts(millis);
+    let unit = match unit {
+        DurationUnit::Minute => "minute",
+        DurationUnit::Hour => "hour",
+        DurationUnit::Day => "day",
    };
    format!("{count} {unit}{}", if count == 1 { "" } else { "s" })
 }
@@ -327,3 +327,19 @@ fn an_allow_line_without_letters_allows_nothing() {
        assert!(f.matches("nigger"), "{line}");
    }
 }
+
+#[test]
+fn duration_parts_preserve_rounding_without_overflow() {
+    for (millis, expected) in [
+        (1, (1, DurationUnit::Minute)),
+        (60_000, (1, DurationUnit::Minute)),
+        (61_000, (2, DurationUnit::Minute)),
+        (3_600_000, (60, DurationUnit::Minute)),
+        (3_600_001, (2, DurationUnit::Hour)),
+        (172_800_000, (48, DurationUnit::Hour)),
+        (172_800_001, (3, DurationUnit::Day)),
+        (i64::MAX, (106_751_991_168, DurationUnit::Day)),
+    ] {
+        assert_eq!(duration_parts(millis), expected);
+    }
+}
@@ -0,0 +1,22 @@
+//! NBT path parser output and byte cursor for the pinned Java oracle.
+use horizon_client_core::nbt_path::NbtPath;
+use std::io::{BufRead, Write};
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut args = std::env::args().skip(1);
+    let input = std::io::BufReader::new(std::fs::File::open(args.next().unwrap())?);
+    let mut output = std::io::BufWriter::new(std::fs::File::create(args.next().unwrap())?);
+    for line in input.lines() {
+        let text: String = serde_json::from_str(&line?)?;
+        match NbtPath::parse_prefix(&text) {
+            Ok((path, cursor)) => {
+                write!(output, "OK {cursor} ")?;
+                for value in path.as_str().as_bytes() {
+                    write!(output, "{value:02x}")?;
+                }
+                writeln!(output)?;
+            }
+            Err(error) => writeln!(output, "ERR {} {}", error.cursor, error.key)?,
+        }
+    }
+    Ok(())
+}
@@ -143,7 +143,9 @@ impl<'a> Fields<'a> {
    /// `RandomizableContainer.tryLoadLootTable` / `trySaveLootTable`; true when the
    /// block entity has a loot table (and so saves no items).
    fn loot_table(&mut self) -> bool {
-        let Some(table) = text(self.input.get("LootTable")) else {
+        let Some(table) =
+            text(self.input.get("LootTable")).and_then(|id| crate::identifier::normalize_id(&id))
+        else {
            return false;
        };
        self.put("LootTable", string(&table));
@@ -905,6 +907,16 @@ mod tests {
        assert_eq!(out.get("LootTable"), Some(&string("minecraft:chests/x")));
    }

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

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

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

+/// `Language.loadFromJson` for one `lang/<code>.json`: its entries go into `map` in file order.
+/// A file that is plain JSON reads as before; any other goes through Gson's lenient reader
+/// (`#`, `//` and `/* */` comments, unquoted or single-quoted names and values, raw control
+/// characters in strings, `=` or `=>` and `;`), which vanilla reads lang files with (expected
+/// from `Language.loadFromJson`, Gson). A file that is not JSON even so adds nothing; a value
+/// that is not a string, number or boolean (`GsonHelper.convertToString`) ends the file there.
+pub fn read_lang_file(bytes: &[u8], map: &mut HashMap<String, String>) {
+    use horizon_world::datafix::json::{Json, parse_lenient};
+    if let Ok(entries) = serde_json::from_slice::<HashMap<String, String>>(bytes) {
+        map.extend(entries);
+        return;
+    }
+    let text = String::from_utf8_lossy(bytes);
+    // Gson's JsonReader skips a leading byte order mark.
+    let text = text.strip_prefix('\u{feff}').unwrap_or(&text);
+    let utf16: Vec<u16> = text.encode_utf16().collect();
+    let Some(Json::Obj(entries)) = parse_lenient(&utf16) else {
+        return;
+    };
+    for (key, value) in entries {
+        let value = match value {
+            Json::Str(s) => String::from_utf16_lossy(&s),
+            Json::Num(n) => n,
+            Json::Bool(b) => b.to_string(),
+            Json::Null | Json::Arr(_) | Json::Obj(_) => break,
+        };
+        map.insert(String::from_utf16_lossy(&key), value);
+    }
+}
+
 impl Language {
    /// ClientLanguage.loadFrom: en_us first, then the selected language, each
    /// from every namespace and every source in priority order (later sources
@@ -413,9 +443,7 @@ impl Language {
                    else {
                        continue;
                    };
-                    if let Ok(entries) = serde_json::from_slice::<HashMap<String, String>>(&bytes) {
-                        map.extend(entries);
-                    }
+                    read_lang_file(&bytes, &mut map);
                }
            }
        }
@@ -875,4 +903,165 @@ mod tests {
            ["en_us", "fr_fr"]
        );
    }
+
+    fn read(body: &str) -> HashMap<String, String> {
+        let mut map = HashMap::new();
+        read_lang_file(body.as_bytes(), &mut map);
+        map
+    }
+    fn entries(pairs: &[(&str, &str)]) -> HashMap<String, String> {
+        pairs
+            .iter()
+            .map(|(k, v)| ((*k).to_owned(), (*v).to_owned()))
+            .collect()
+    }
+
+    #[test]
+    fn a_plain_json_lang_file_reads_as_before() {
+        let body = "{\"a\": \"Apple \\\"quoted\\\" \\u00e9\", \"b\": \"\", \"a\": \"Again\"}";
+        let strict: HashMap<String, String> = serde_json::from_str(body).unwrap();
+        assert_eq!(read(body), strict);
+        assert_eq!(read(body), entries(&[("a", "Again"), ("b", "")]));
+    }
+
+    #[test]
+    fn lang_files_read_with_comments() {
+        let want = entries(&[("a", "Apple"), ("b", "Banana # not a comment // either")]);
+        for body in [
+            "# header\n{\n# a comment\n\"a\": \"Apple\",\n\"b\": \"Banana # not a comment // either\"\n}\n",
+            "// header\n{\"a\": \"Apple\", // after\n\"b\": \"Banana # not a comment // either\"}",
+            "/* header\n over lines */{\"a\": /* inline */ \"Apple\", \"b\": \"Banana # not a comment // either\"}",
+        ] {
+            assert_eq!(read(body), want, "{body}");
+        }
+    }
+
+    #[test]
+    fn lang_files_read_unquoted_and_single_quoted_names_and_values() {
+        assert_eq!(
+            read("{a: 'Apple', 'b': \"Banana\", c: Cherry}"),
+            entries(&[("a", "Apple"), ("b", "Banana"), ("c", "Cherry")])
+        );
+        // A single-quoted string may hold a double quote, and the reverse.
+        assert_eq!(
+            read("{'a': 'say \"hi\"', \"b\": \"it's\"}"),
+            entries(&[("a", "say \"hi\""), ("b", "it's")])
+        );
+    }
+
+    #[test]
+    fn lang_files_read_raw_control_characters_in_strings() {
+        assert_eq!(
+            read("{\"a\": \"tab\there\", \"b\": \"two\nlines\"}"),
+            entries(&[("a", "tab\there"), ("b", "two\nlines")])
+        );
+    }
+
+    #[test]
+    fn lang_files_read_gson_separators_and_a_byte_order_mark() {
+        assert_eq!(
+            read("\u{feff}{\"a\" = \"Apple\"; \"b\" => \"Banana\"}"),
+            entries(&[("a", "Apple"), ("b", "Banana")])
+        );
+        // A trailing comma before `}` is not JSON even to Gson's lenient reader.
+        assert_eq!(read("{# c\n\"a\": \"Apple\",}"), HashMap::new());
+    }
+
+    #[test]
+    fn numbers_and_booleans_read_as_their_text() {
+        // GsonHelper.convertToString: a primitive reads as its text.
+        assert_eq!(
+            read("{\"a\": 1.50, \"b\": true, \"c\": -2e3}"),
+            entries(&[("a", "1.50"), ("b", "true"), ("c", "-2e3")])
+        );
+    }
+
+    #[test]
+    fn a_value_that_is_no_text_ends_the_file_there() {
+        assert_eq!(
+            read("# c\n{\"a\": \"Apple\", \"b\": [\"x\"], \"c\": \"Cherry\"}"),
+            entries(&[("a", "Apple")])
+        );
+        assert_eq!(read("{\"a\": null, \"b\": \"Banana\"}"), HashMap::new());
+    }
+
+    #[test]
+    fn a_lang_file_that_is_not_json_adds_nothing() {
+        for body in [
+            "# c\n{\"a\": \"Apple\"",
+            "[\"a\"]",
+            "\"a\"",
+            "",
+            "{\"a\": \"Apple\"} {",
+        ] {
+            assert_eq!(read(body), HashMap::new(), "{body:?}");
+        }
+    }
+
+    #[test]
+    fn a_pack_lang_file_with_comments_layers_over_english() {
+        let base = Mem(HashMap::from([(
+            "assets/minecraft/lang/en_us.json".into(),
+            br#"{"a":"Apple","b":"Banana"}"#.to_vec(),
+        )]));
+        let pack = Mem(HashMap::from([(
+            "assets/minecraft/lang/fr_fr.json".into(),
+            b"{\n# Fruits\n\"a\": \"Pomme\"\n}\n".to_vec(),
+        )]));
+        let sources: [&dyn ResourceSource; 2] = [&base, &pack];
+        let fr = Language::load(&sources, "fr_fr");
+        assert_eq!(fr.get("a"), Some("Pomme"));
+        assert_eq!(fr.get("b"), Some("Banana"));
+    }
+
+    /// Every lang file of a downloaded pack, e.g. BACAP Language Pack:
+    /// `HORIZON_LANG_PACK_DIR=<pack>/assets/minecraft/lang cargo test -p horizon-client-core
+    /// lang::tests::every_lang_file_of_a_pack_reads -- --ignored --nocapture`.
+    #[test]
+    #[ignore = "needs a downloaded pack in HORIZON_LANG_PACK_DIR"]
+    fn every_lang_file_of_a_pack_reads() {
+        let Ok(dir) = std::env::var("HORIZON_LANG_PACK_DIR") else {
+            return;
+        };
+        let mut failed = Vec::new();
+        let mut paths: Vec<_> = std::fs::read_dir(dir)
+            .unwrap()
+            .map(|e| e.unwrap().path())
+            .collect();
+        paths.sort();
+        for path in paths {
+            let bytes = std::fs::read(&path).unwrap();
+            let strict = serde_json::from_slice::<HashMap<String, String>>(&bytes).is_ok();
+            let mut map = HashMap::new();
+            read_lang_file(&bytes, &mut map);
+            // An independent count: the distinct `"name":` that start a line.
+            let text = String::from_utf8_lossy(&bytes);
+            let names: std::collections::HashSet<&str> = text
+                .lines()
+                .filter_map(|line| {
+                    let rest = line.trim_start().strip_prefix('"')?;
+                    let mut escaped = false;
+                    let end = rest.char_indices().find_map(|(i, c)| {
+                        let close = c == '"' && !escaped;
+                        escaped = c == '\\' && !escaped;
+                        close.then_some(i)
+                    })?;
+                    rest[end + 1..]
+                        .trim_start()
+                        .starts_with(':')
+                        .then(|| &rest[..end])
+                })
+                .collect();
+            println!(
+                "{}: strict {strict}, {} keys, {} names",
+                path.display(),
+                map.len(),
+                names.len()
+            );
+            if map.is_empty() || map.len() != names.len() {
+                failed.push(path);
+            }
+        }
+        assert!(failed.is_empty(), "{failed:?}");
+    }
 }
@@ -79,28 +79,65 @@ fn elements(tag: &Tag) -> Option<Vec<Tag>> {
        _ => return None,
    })
 }
-fn number(t: &Tag) -> Option<i64> {
-    match t {
-        Tag::Byte(v) => Some(i64::from(*v)),
-        Tag::Short(v) => Some(i64::from(*v)),
-        Tag::Int(v) => Some(i64::from(*v)),
-        Tag::Long(v) => Some(*v),
-        _ => None,
+/// `DoubleTag.intValue` / `FloatTag.intValue` floor before the i32 conversion;
+/// integral tags use their intValue narrowing. Byte arrays then keep the low byte.
+pub fn int_value(t: &Tag) -> Option<i32> {
+    Some(match t {
+        Tag::Byte(v) => i32::from(*v),
+        Tag::Short(v) => i32::from(*v),
+        Tag::Int(v) => *v,
+        Tag::Long(v) => *v as i32,
+        Tag::Float(v) => f32::from_bits(*v).floor() as i32,
+        Tag::Double(v) => f64::from_bits(*v).floor() as i32,
+        _ => return None,
+    })
+}
+/// `FloatTag.longValue` truncates; `DoubleTag.longValue` floors before narrowing.
+fn long_value(t: &Tag) -> Option<i64> {
+    Some(match t {
+        Tag::Byte(v) => i64::from(*v),
+        Tag::Short(v) => i64::from(*v),
+        Tag::Int(v) => i64::from(*v),
+        Tag::Long(v) => *v,
+        // FloatTag.longValue truncates; DoubleTag.longValue floors first.
+        Tag::Float(v) => f32::from_bits(*v) as i64,
+        Tag::Double(v) => f64::from_bits(*v).floor() as i64,
+        _ => return None,
+    })
+}
+#[derive(Clone, Copy)]
+enum ElementKind {
+    List,
+    NumericArray,
+}
+impl ElementKind {
+    // Admission only: arrays require NumericTag; lists accept every tag type.
+    fn accepts(self, value: &Tag) -> bool {
+        matches!(self, Self::List)
+            || matches!(
+                value,
+                Tag::Byte(_)
+                    | Tag::Short(_)
+                    | Tag::Int(_)
+                    | Tag::Long(_)
+                    | Tag::Float(_)
+                    | Tag::Double(_)
+            )
    }
 }
-/// Run `f` over the elements of a list/array, writing array results back.
+/// Rust view adapter: run `f` over the elements, then write arrays using their numeric accessor.
 /// None when `tag` is not list-like.
-fn with_elements<R>(tag: &mut Tag, f: impl FnOnce(&mut Vec<Tag>) -> R) -> Option<R> {
+fn with_elements<R>(tag: &mut Tag, f: impl FnOnce(&mut Vec<Tag>, ElementKind) -> R) -> Option<R> {
    match tag {
-        Tag::List(l) => Some(f(l)),
+        Tag::List(l) => Some(f(l, ElementKind::List)),
        Tag::ByteArray(_) | Tag::IntArray(_) | Tag::LongArray(_) => {
            let mut v = elements(tag)?;
-            let r = f(&mut v);
-            let nums: Vec<i64> = v.iter().filter_map(number).collect();
+            let r = f(&mut v, ElementKind::NumericArray);
            match tag {
-                Tag::ByteArray(a) => *a = nums.iter().map(|n| *n as u8).collect(),
-                Tag::IntArray(a) => *a = nums.iter().map(|n| *n as i32).collect(),
-                Tag::LongArray(a) => *a = nums,
+                // Float/double byteValue uses intValue's floor, then narrows.
+                Tag::ByteArray(a) => *a = v.iter().filter_map(int_value).map(|n| n as u8).collect(),
+                Tag::IntArray(a) => *a = v.iter().filter_map(int_value).collect(),
+                Tag::LongArray(a) => *a = v.iter().filter_map(long_value).collect(),
                _ => {}
            }
            Some(r)
@@ -157,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(
@@ -349,7 +400,7 @@ impl NbtPath {
        });
        removed
    }
-    /// `insert` (also append and prepend): into every list the path reaches.
+    /// `NbtPathArgument.NbtPath.insert`: insert accepted tags into every reached collection.
    pub fn insert(
        &self,
        index: i32,
@@ -372,19 +423,23 @@ impl NbtPath {
                return;
            }
            let shown = crate::snbt::to_snbt(target);
-            let result = with_elements(target, |list| {
+            let result = with_elements(target, |list, kind| {
                let start = if index < 0 {
                    list.len() as i64 + i64::from(index) + 1
                } else {
                    i64::from(index)
                };
                let mut any = false;
-                for (n, v) in values.iter().enumerate() {
-                    let at = start + n as i64;
+                let mut at = start;
+                for v in values {
+                    if !kind.accepts(v) {
+                        continue;
+                    }
                    if at < 0 || at as usize > list.len() {
                        return Err(CollectionError::InvalidIndex(at as i32));
                    }
                    list.insert(at as usize, v.clone());
+                    at += 1;
                    any = true;
                }
                Ok(any)
@@ -428,7 +483,8 @@ fn preferred_parent(node: &Node) -> Tag {
        _ => Tag::Compound(Compound::new()),
    }
 }
-/// `getOrCreateTag` (or `getTag` without `create`): the children of `parent`.
+/// Children of `parent`; the array creation arm follows
+/// `NbtPathArgument.AllElementsNode.getOrCreateTag` admission.
 fn step_mut(
    node: &Node,
    parent: &mut Tag,
@@ -468,11 +524,14 @@ fn step_mut(
        }
        Node::AllElements => {
            let make = create;
-            let _ = with_elements(parent, |list| {
+            let _ = with_elements(parent, |list, kind| {
                if list.is_empty() {
                    if let Some(make) = make {
-                        list.push(make());
-                        out(&mut list[0]);
+                        let value = make();
+                        if kind.accepts(&value) {
+                            list.push(value);
+                            out(&mut list[0]);
+                        }
                    }
                } else {
                    for t in list.iter_mut() {
@@ -482,7 +541,7 @@ fn step_mut(
            });
        }
        Node::Index(i) => {
-            let _ = with_elements(parent, |list| {
+            let _ = with_elements(parent, |list, _kind| {
                let n = list.len() as i64;
                let idx = if *i < 0 {
                    n + i64::from(*i)
@@ -518,7 +577,8 @@ fn step_mut(
        }
    }
 }
-/// `Node.setTag`: replace the child(ren) of `parent` with `value`.
+/// Element setters follow `NbtPathArgument.AllElementsNode.setTag` and
+/// `NbtPathArgument.IndexedElementNode.setTag`; object nodes replace their children.
 fn set_tag(node: &Node, parent: &mut Tag, value: &Tag) -> usize {
    match node {
        Node::Child(name) => {
@@ -538,29 +598,36 @@ fn set_tag(node: &Node, parent: &mut Tag, value: &Tag) -> usize {
            }
            0
        }
-        Node::AllElements => with_elements(parent, |list| {
-            if list.is_empty() {
-                list.push(value.clone());
+        Node::AllElements => with_elements(parent, |list, kind| {
+            let len = list.len();
+            if len == 0 {
+                if kind.accepts(value) {
+                    list.push(value.clone());
+                }
+                // AllElementsNode returns 1 here even when addTag rejects.
                return 1;
            }
+            // Compare the original tags, before numeric conversion.
            let changed = list.iter().filter(|t| *t != value).count();
            if changed == 0 {
                return 0;
            }
-            for t in list.iter_mut() {
-                *t = value.clone();
+            list.clear();
+            if !kind.accepts(value) {
+                return 0;
            }
+            list.resize(len, value.clone());
            changed
        })
        .unwrap_or(0),
-        Node::Index(i) => with_elements(parent, |list| {
+        Node::Index(i) => with_elements(parent, |list, kind| {
            let n = list.len() as i64;
            let idx = if *i < 0 {
                n + i64::from(*i)
            } else {
                i64::from(*i)
            };
-            if (0..n).contains(&idx) && list[idx as usize] != *value {
+            if (0..n).contains(&idx) && list[idx as usize] != *value && kind.accepts(value) {
                list[idx as usize] = value.clone();
                1
            } else {
@@ -586,6 +653,7 @@ fn set_tag(node: &Node, parent: &mut Tag, value: &Tag) -> usize {
        Node::MatchRoot(_) => 0,
    }
 }
+/// Removal arms, including `NbtPathArgument.AllElementsNode.removeTag`.
 fn remove_tag(node: &Node, parent: &mut Tag) -> usize {
    match node {
        Node::Child(name) => match parent {
@@ -603,13 +671,13 @@ fn remove_tag(node: &Node, parent: &mut Tag) -> usize {
            }
            _ => 0,
        },
-        Node::AllElements => with_elements(parent, |l| {
+        Node::AllElements => with_elements(parent, |l, _kind| {
            let n = l.len();
            l.clear();
            n
        })
        .unwrap_or(0),
-        Node::Index(i) => with_elements(parent, |l| {
+        Node::Index(i) => with_elements(parent, |l, _kind| {
            let n = l.len() as i64;
            let idx = if *i < 0 {
                n + i64::from(*i)
@@ -658,11 +726,16 @@ fn parse_node(text: &str, i: usize, first: bool) -> Result<(Node, usize), PathEr
                Some(b']') => Ok((Node::AllElements, j + 1)),
                _ => {
                    let start = j;
-                    if b.get(j) == Some(&b'-') {
+                    // StringReader.readInt scans all allowed number characters
+                    // before parsing, including malformed signs and decimal points.
+                    while b
+                        .get(j)
+                        .is_some_and(|c| c.is_ascii_digit() || matches!(c, b'-' | b'.'))
+                    {
                        j += 1;
                    }
-                    while b.get(j).is_some_and(u8::is_ascii_digit) {
-                        j += 1;
+                    if start == j {
+                        return Err(PathError::new("parsing.int.expected", vec![], start));
                    }
                    let n: i32 = text[start..j].parse().map_err(|_| {
                        PathError::new(
@@ -724,6 +797,13 @@ fn read_quoted(text: &str, i: usize) -> Result<(String, usize), PathError> {
    let mut escaped = false;
    for (o, c) in text[i + 1..].char_indices() {
        if escaped {
+            if c != quote && c != '\\' {
+                return Err(PathError::new(
+                    "parsing.quote.escape",
+                    vec![c.to_string()],
+                    i + 1 + o,
+                ));
+            }
            out.push(c);
            escaped = false;
        } else if c == '\\' {
@@ -772,6 +852,59 @@ fn parse_compound(text: &str, i: usize) -> Result<(Tag, usize), PathError> {
 #[cfg(test)]
 mod tests {
    use super::*;
+    #[test]
+    fn quoted_escapes_and_index_tokens_match_brigadier() {
+        let cases = [
+            (r#""a\q""#, "parsing.quote.escape", vec!["q"], 3),
+            (r#"'a\x'"#, "parsing.quote.escape", vec!["x"], 3),
+            ("[1.0]", "parsing.int.invalid", vec!["1.0"], 1),
+            ("[.]", "parsing.int.invalid", vec!["."], 1),
+            ("[--1]", "parsing.int.invalid", vec!["--1"], 1),
+            ("[2147483648]", "parsing.int.invalid", vec!["2147483648"], 1),
+            ("[+1]", "parsing.int.expected", vec![], 1),
+            (r#""é\q""#, "parsing.quote.escape", vec!["q"], 4),
+            (r#""é"[1.0]"#, "parsing.int.invalid", vec!["1.0"], 5),
+        ];
+        let mut failures = Vec::new();
+        for (text, key, args, cursor) in cases {
+            match NbtPath::parse_prefix(text) {
+                Err(error) if error.key == key && error.args == args && error.cursor == cursor => {}
+                other => failures.push(format!("{text:?}: {other:?}")),
+            }
+        }
+        assert!(failures.is_empty(), "{}", failures.join("\n"));
+    }
+
+    #[test]
+    fn valid_quoted_escapes_still_select_the_exact_field() {
+        let root = Tag::compound([("a\"b", Tag::Int(7)), ("a\\b", Tag::Int(8))]);
+        for (path, value) in [(r#""a\"b""#, 7), (r#""a\\b""#, 8)] {
+            assert_eq!(
+                NbtPath::parse(path).unwrap().get(&root).unwrap(),
+                vec![Tag::Int(value)]
+            );
+        }
+    }
+
+    #[test]
+    fn field_provenance_handles_quotes_and_filters_without_matching_lists() {
+        for text in [
+            "blockState.properties",
+            "\"blockState\".\"properties\"",
+            "{source:1b}.blockState.properties",
+            "blockState{id:\"minecraft:piston_head\"}.properties",
+        ] {
+            let path = NbtPath::parse(text).unwrap();
+            assert!(path.is_field_path(&["blockState", "properties"]));
+            assert!(!path.is_field_path(&["blockState"]));
+        }
+        assert!(NbtPath::parse("{source:1b}").unwrap().is_field_path(&[]));
+        assert!(
+            !NbtPath::parse("blockState[].properties")
+                .unwrap()
+                .is_field_path(&["blockState", "properties"])
+        );
+    }

    fn tag(s: &str) -> Tag {
        parse_snbt(s).unwrap().0
@@ -887,6 +1020,100 @@ mod tests {
        ));
    }

+    #[test]
+    fn numeric_array_edits_use_the_destination_numeric_accessor() {
+        for (initial, value, inserted, indexed, all) in [
+            (
+                "{v:[B;1b,2b]}",
+                "-3.5f",
+                "{v:[B;1b,-4b,2b]}",
+                "{v:[B;-4b,2b]}",
+                "{v:[B;-4b,-4b]}",
+            ),
+            (
+                "{v:[B;1b,2b]}",
+                "-3.5d",
+                "{v:[B;1b,-4b,2b]}",
+                "{v:[B;-4b,2b]}",
+                "{v:[B;-4b,-4b]}",
+            ),
+            (
+                "{v:[I;1,2]}",
+                "-3.5f",
+                "{v:[I;1,-4,2]}",
+                "{v:[I;-4,2]}",
+                "{v:[I;-4,-4]}",
+            ),
+            (
+                "{v:[I;1,2]}",
+                "-3.5d",
+                "{v:[I;1,-4,2]}",
+                "{v:[I;-4,2]}",
+                "{v:[I;-4,-4]}",
+            ),
+            (
+                "{v:[L;1L,2L]}",
+                "-3.5f",
+                "{v:[L;1L,-3L,2L]}",
+                "{v:[L;-3L,2L]}",
+                "{v:[L;-3L,-3L]}",
+            ),
+            (
+                "{v:[L;1L,2L]}",
+                "-3.5d",
+                "{v:[L;1L,-4L,2L]}",
+                "{v:[L;-4L,2L]}",
+                "{v:[L;-4L,-4L]}",
+            ),
+        ] {
+            let value = tag(value);
+            let mut root = tag(initial);
+            assert_eq!(
+                path("v")
+                    .insert(1, &mut root, std::slice::from_ref(&value))
+                    .unwrap(),
+                1
+            );
+            assert_eq!(root, tag(inserted));
+            let mut root = tag(initial);
+            assert_eq!(path("v[0]").set(&mut root, &value).unwrap(), 1);
+            assert_eq!(root, tag(indexed));
+            let mut root = tag(initial);
+            assert_eq!(path("v[]").set(&mut root, &value).unwrap(), 2);
+            assert_eq!(root, tag(all));
+        }
+    }
+
+    #[test]
+    fn numeric_arrays_reject_nonnumeric_insert_and_indexed_set() {
+        for initial in ["{v:[B;1b,2b]}", "{v:[I;1,2]}", "{v:[L;1L,2L]}"] {
+            let original = tag(initial);
+            let value = tag("\"bad\"");
+            for index in [0, 99, -99] {
+                let mut root = original.clone();
+                assert_eq!(
+                    path("v")
+                        .insert(index, &mut root, std::slice::from_ref(&value))
+                        .unwrap(),
+                    0
+                );
+                assert_eq!(root, original);
+            }
+            let mut root = original.clone();
+            assert_eq!(path("v[0]").set(&mut root, &value).unwrap(), 0);
+            assert_eq!(root, original);
+        }
+    }
+
+    #[test]
+    fn empty_array_wildcard_set_preserves_vanillas_count_on_rejection() {
+        for initial in ["{v:[B;]}", "{v:[I;]}", "{v:[L;]}"] {
+            let mut root = tag(initial);
+            assert_eq!(path("v[]").set(&mut root, &tag("\"bad\"")).unwrap(), 1);
+            assert_eq!(root, tag(initial));
+        }
+    }
+
    #[test]
    fn partial_comparison() {
        let actual = tag("{a:1,b:{c:[1,2,3],d:\"x\"},e:2}");
@@ -173,6 +173,16 @@ impl Registries {
        fill(&mut self.templates, "templates");
        fill(&mut self.persistent_components, "persistent_components");
        fill(&mut self.learnable_recipes, "learnable_recipes");
+        if self.summonable.is_empty() {
+            self.summonable = strings(&r["summonable"]);
+            self.summonable.sort();
+            self.summonable.dedup();
+        }
+        if self.entity_types.is_empty() {
+            self.entity_types = strings(&r["entity_types"]);
+            self.entity_types.sort();
+            self.entity_types.dedup();
+        }
        const RELOADED: [&str; 5] = [
            "minecraft:advancement",
            "minecraft:recipe",
@@ -236,6 +246,16 @@ impl Registries {
        fill(&mut self.templates, &e.templates);
        fill(&mut self.persistent_components, &e.persistent_components);
        fill(&mut self.learnable_recipes, &e.learnable_recipes);
+        if self.summonable.is_empty() {
+            self.summonable.clone_from(&e.summonable);
+            self.summonable.sort();
+            self.summonable.dedup();
+        }
+        if self.entity_types.is_empty() {
+            self.entity_types.clone_from(&e.entity_types);
+            self.entity_types.sort();
+            self.entity_types.dedup();
+        }
        for (name, ids) in &e.by_registry {
            if !self.by_registry.contains_key(name) {
                self.by_registry.insert(name.clone(), ids.clone());
@@ -964,6 +964,10 @@ impl Scoreboard {
    pub fn tracked(&self) -> Vec<String> {
        self.holder_order.stream().map(str::to_owned).collect()
    }
+    /// Every holder on a team (`teamsByPlayer.keySet()`).
+    pub fn team_members(&self) -> impl Iterator<Item = &str> {
+        self.team_of.keys().map(String::as_str)
+    }

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

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

+/// Writer provenance for a live moving-piston command read, or its selected subtree.
+#[derive(Clone, Copy)]
+pub enum PistonPart {
+    Entity,
+    State,
+    Properties,
+}
+
 struct Pretty {
    indentation: String,
    result: Text,
    indent_depth: usize,
    depth: usize,
+    piston: Option<PistonPart>,
 }
 fn is_numeric(t: &Tag) -> bool {
    matches!(
@@ -58,6 +67,10 @@ impl Pretty {
        self.lit("]", None);
    }
    fn sub(&mut self, tag: &Tag, indent: bool) {
+        self.sub_with(tag, indent, None);
+    }
+    fn sub_with(&mut self, tag: &Tag, indent: bool, piston: Option<PistonPart>) {
+        let previous = std::mem::replace(&mut self.piston, piston);
        if indent {
            self.indent_depth += 1;
        }
@@ -67,6 +80,7 @@ impl Pretty {
            self.indent_depth -= 1;
        }
        self.depth -= 1;
+        self.piston = previous;
    }
    fn visit(&mut self, tag: &Tag) {
        match tag {
@@ -157,7 +171,11 @@ impl Pretty {
                "\n"
            };
            let n = c.len();
-            for (i, (k, v)) in java_hash_order(c).into_iter().enumerate() {
+            let entries = match self.piston {
+                Some(part) => piston_hash_order(c, part),
+                None => java_hash_order(c),
+            };
+            for (i, (k, v)) in entries.into_iter().enumerate() {
                self.lit(&entry, None);
                let key = string_of(k);
                if !key.is_empty()
@@ -171,7 +189,12 @@ impl Pretty {
                }
                self.lit(":", None);
                self.lit(" ", None);
-                self.sub(v, true);
+                let child = match (self.piston, key.as_str()) {
+                    (Some(PistonPart::Entity), "blockState") => Some(PistonPart::State),
+                    (Some(PistonPart::State), "properties") => Some(PistonPart::Properties),
+                    _ => None,
+                };
+                self.sub_with(v, true, child);
                if i + 1 < n {
                    self.lit(",", None);
                    self.lit(spacing, None);
@@ -186,22 +209,61 @@ impl Pretty {
        }
    }
 }
+fn hash_bucket(len: usize, key: &horizon_world::nbt::JavaString) -> usize {
+    let mut capacity = 16usize;
+    while len > capacity * 3 / 4 {
+        capacity *= 2;
+    }
+    let h = string_of(key)
+        .encode_utf16()
+        .fold(0u32, |h, ch| h.wrapping_mul(31).wrapping_add(u32::from(ch)));
+    ((h ^ (h >> 16)) as usize) & (capacity - 1)
+}
+fn piston_hash_order(
+    c: &horizon_world::nbt::Compound,
+    part: PistonPart,
+) -> Vec<(&horizon_world::nbt::JavaString, &Tag)> {
+    let mut entries: Vec<_> = c.iter().collect();
+    match part {
+        PistonPart::Entity => {
+            // saveAdditional, then the base's components and saveMetadata.
+            let fields = [
+                "blockState",
+                "facing",
+                "progress",
+                "extending",
+                "source",
+                "components",
+                "id",
+                "x",
+                "y",
+                "z",
+            ];
+            entries.sort_by_key(|(k, _)| {
+                (
+                    hash_bucket(c.len(), k),
+                    fields
+                        .iter()
+                        .position(|s| *s == string_of(k))
+                        .unwrap_or(fields.len()),
+                )
+            });
+        }
+        PistonPart::Properties => {
+            // StateDefinition builds property codecs in sorted-name order.
+            // DFU's nested map-pair encoder writes the second codec first.
+            entries.sort_by_key(|(k, _)| (hash_bucket(c.len(), k), std::cmp::Reverse(*k)));
+        }
+        PistonPart::State => return java_hash_order(c),
+    }
+    entries
+}
 /// The iteration order of the `HashMap<String, Tag>` a `CompoundTag` holds,
 /// for a map that grew to its size by insertion: buckets by
 /// `HashMap.hash(String.hashCode())`, keys sharing a bucket in key order.
 pub fn java_hash_order(
    c: &horizon_world::nbt::Compound,
 ) -> Vec<(&horizon_world::nbt::JavaString, &Tag)> {
-    let mut capacity = 16usize;
-    while c.len() > capacity * 3 / 4 {
-        capacity *= 2;
-    }
-    let bucket = |k: &horizon_world::nbt::JavaString| {
-        let h = string_of(k)
-            .encode_utf16()
-            .fold(0u32, |h, ch| h.wrapping_mul(31).wrapping_add(u32::from(ch)));
-        ((h ^ (h >> 16)) as usize) & (capacity - 1)
-    };
    // Keys sharing a bucket iterate in insertion order: the order vanilla's
    // savers write them, as far as it is known here.
    const WRITE_ORDER: &[&str] = &[
@@ -268,7 +330,7 @@ pub fn java_hash_order(
            .unwrap_or(WRITE_ORDER.len())
    };
    let mut entries: Vec<_> = c.iter().collect();
-    entries.sort_by_key(|(k, _)| (bucket(k), rank(k)));
+    entries.sort_by_key(|(k, _)| (hash_bucket(c.len(), k), rank(k)));
    entries
 }
 /// `NbtUtils.toPrettyComponent`: the coloured, unindented form.
@@ -281,6 +343,19 @@ pub fn pretty_indented(tag: &Tag, indentation: &str) -> Text {
        result: Text::empty(),
        indent_depth: 0,
        depth: 0,
+        piston: None,
+    };
+    p.visit(tag);
+    p.result
+}
+/// Command-only writer order; ordinary pretty printing keeps its existing policy.
+pub fn pretty_piston(tag: &Tag, part: PistonPart) -> Text {
+    let mut p = Pretty {
+        indentation: String::new(),
+        result: Text::empty(),
+        indent_depth: 0,
+        depth: 0,
+        piston: Some(part),
    };
    p.visit(tag);
    p.result
@@ -295,6 +370,33 @@ mod tests {
        to_snbt(&parse_snbt(s).unwrap().0)
    }
    #[test]
+    fn live_piston_writer_order_does_not_change_default_pretty() {
+        let tag = parse_snbt(
+            r#"{id:"minecraft:piston",blockState:{id:"minecraft:piston_head",properties:{facing:"east",short:"false",type:"normal"}},components:{},x:1,y:100,z:0,facing:5b,progress:0.0f,source:1b,extending:1b}"#,
+        ).unwrap().0;
+        let ordinary = r#"{blockState: {id: "minecraft:piston_head", properties: {facing: "east", short: "false", type: "normal"}}, components: {}, x: 1, facing: 5b, progress: 0.0f, y: 100, z: 0, id: "minecraft:piston", source: 1b, extending: 1b}"#;
+        assert_eq!(pretty(&tag).plain(), ordinary);
+        assert_eq!(
+            pretty_piston(&tag, PistonPart::Entity).plain(),
+            r#"{blockState: {id: "minecraft:piston_head", properties: {short: "false", facing: "east", type: "normal"}}, components: {}, x: 1, facing: 5b, progress: 0.0f, y: 100, z: 0, source: 1b, id: "minecraft:piston", extending: 1b}"#,
+        );
+        let state = tag.get("blockState").unwrap();
+        assert_eq!(
+            pretty_piston(state, PistonPart::State).plain(),
+            r#"{id: "minecraft:piston_head", properties: {short: "false", facing: "east", type: "normal"}}"#,
+        );
+        let props = state.get("properties").unwrap();
+        assert_eq!(
+            pretty_piston(props, PistonPart::Properties).plain(),
+            r#"{short: "false", facing: "east", type: "normal"}"#,
+        );
+        assert_eq!(
+            pretty(props).plain(),
+            r#"{facing: "east", short: "false", type: "normal"}"#
+        );
+        assert_eq!(pretty(&tag).plain(), ordinary);
+    }
+    #[test]
    fn compact_form_matches_vanilla() {
        assert_eq!(
            rt("{b:1b,a:\"x\",c:[1,2],d:1.5f,e:2d,f:3L,g:4s}"),
@@ -0,0 +1,146 @@
+//! Every input the game names: vanilla's key mappings (`Options.keyMappings`) and Horizon's
+//! pad-only actions. Held state is asked by [`Action`] ([`crate::held::HeldKeys::held`]), not by a
+//! key: code that wants a mapping says which one, and every device that can hold it counts.
+use winit::keyboard::KeyCode;
+
+macro_rules! actions {
+    ($($variant:ident, $name:literal, $key:expr;)*) => {
+        /// A key mapping, or a pad-only action.
+        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+        pub enum Action {
+            $($variant,)*
+        }
+        impl Action {
+            /// In `Options.keyMappings` order, then Horizon's own mappings, the pad-only actions last.
+            pub const ALL: &[Action] = &[$(Action::$variant,)*];
+            /// The saved name: vanilla's for a mapping, `pad.*` for Horizon's own.
+            pub fn name(self) -> &'static str {
+                match self {
+                    $(Action::$variant => $name,)*
+                }
+            }
+            /// The default key the game's held state keeps this action under. `None` for what
+            /// isn't held as a key there: a mouse mapping, one with no default, a pad-only action,
+            /// and the debug keys, which act on the physical key (`debug_keys.rs`) and whose
+            /// defaults are other mappings' keys.
+            pub fn key(self) -> Option<KeyCode> {
+                match self {
+                    $(Action::$variant => $key,)*
+                }
+            }
+        }
+    };
+}
+
+actions! {
+    Attack, "key.attack", None;
+    Use, "key.use", None;
+    Forward, "key.forward", Some(KeyCode::KeyW);
+    Left, "key.left", Some(KeyCode::KeyA);
+    Back, "key.back", Some(KeyCode::KeyS);
+    Right, "key.right", Some(KeyCode::KeyD);
+    Jump, "key.jump", Some(KeyCode::Space);
+    Sneak, "key.sneak", Some(KeyCode::ShiftLeft);
+    Sprint, "key.sprint", Some(KeyCode::ControlLeft);
+    Drop, "key.drop", Some(KeyCode::KeyQ);
+    Inventory, "key.inventory", Some(KeyCode::KeyE);
+    Chat, "key.chat", Some(KeyCode::KeyT);
+    Playerlist, "key.playerlist", Some(KeyCode::Tab);
+    PickItem, "key.pickItem", None;
+    Command, "key.command", Some(KeyCode::Slash);
+    Friends, "key.friends", Some(KeyCode::KeyO);
+    SocialInteractions, "key.socialInteractions", Some(KeyCode::KeyP);
+    ToggleGui, "key.toggleGui", Some(KeyCode::F1);
+    ToggleSpectatorShaderEffects, "key.toggleSpectatorShaderEffects", Some(KeyCode::F4);
+    Screenshot, "key.screenshot", Some(KeyCode::F2);
+    TogglePerspective, "key.togglePerspective", Some(KeyCode::F5);
+    SmoothCamera, "key.smoothCamera", None;
+    Fullscreen, "key.fullscreen", Some(KeyCode::F11);
+    SpectatorOutlines, "key.spectatorOutlines", None;
+    SpectatorHotbar, "key.spectatorHotbar", None;
+    SwapOffhand, "key.swapOffhand", Some(KeyCode::KeyF);
+    SaveToolbarActivator, "key.saveToolbarActivator", Some(KeyCode::KeyC);
+    LoadToolbarActivator, "key.loadToolbarActivator", Some(KeyCode::KeyX);
+    Advancements, "key.advancements", Some(KeyCode::KeyL);
+    QuickActions, "key.quickActions", Some(KeyCode::KeyG);
+    DebugOverlay, "key.debug.overlay", None;
+    DebugModifier, "key.debug.modifier", None;
+    Hotbar1, "key.hotbar.1", Some(KeyCode::Digit1);
+    Hotbar2, "key.hotbar.2", Some(KeyCode::Digit2);
+    Hotbar3, "key.hotbar.3", Some(KeyCode::Digit3);
+    Hotbar4, "key.hotbar.4", Some(KeyCode::Digit4);
+    Hotbar5, "key.hotbar.5", Some(KeyCode::Digit5);
+    Hotbar6, "key.hotbar.6", Some(KeyCode::Digit6);
+    Hotbar7, "key.hotbar.7", Some(KeyCode::Digit7);
+    Hotbar8, "key.hotbar.8", Some(KeyCode::Digit8);
+    Hotbar9, "key.hotbar.9", Some(KeyCode::Digit9);
+    DebugReloadChunk, "key.debug.reloadChunk", None;
+    DebugShowHitboxes, "key.debug.showHitboxes", None;
+    DebugClearChat, "key.debug.clearChat", None;
+    DebugCrash, "key.debug.crash", None;
+    DebugShowChunkBorders, "key.debug.showChunkBorders", None;
+    DebugShowAdvancedTooltips, "key.debug.showAdvancedTooltips", None;
+    DebugCopyRecreateCommand, "key.debug.copyRecreateCommand", None;
+    DebugSpectate, "key.debug.spectate", None;
+    DebugSwitchGameMode, "key.debug.switchGameMode", None;
+    DebugDebugOptions, "key.debug.debugOptions", None;
+    DebugFocusPause, "key.debug.focusPause", None;
+    DebugDumpDynamicTextures, "key.debug.dumpDynamicTextures", None;
+    DebugReloadResourcePacks, "key.debug.reloadResourcePacks", None;
+    DebugProfiling, "key.debug.profiling", None;
+    DebugCopyLocation, "key.debug.copyLocation", None;
+    DebugDumpVersion, "key.debug.dumpVersion", None;
+    DebugProfilingChart, "key.debug.profilingChart", None;
+    DebugFpsCharts, "key.debug.fpsCharts", None;
+    DebugNetworkCharts, "key.debug.networkCharts", None;
+    DebugLightmapTexture, "key.debug.lightmapTexture", None;
+    DebugImprovedTransparency, "key.debug.improvedTransparency", None;
+    Emote, "key.emote", Some(KeyCode::KeyB);
+    HotbarPrevious, "pad.hotbarPrevious", None;
+    HotbarNext, "pad.hotbarNext", None;
+}
+
+impl Action {
+    pub fn parse(name: &str) -> Option<Self> {
+        Self::ALL.iter().copied().find(|a| a.name() == name)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::keybinds::{self, HORIZON_MAPPINGS, KeyBinds, MAPPINGS, all_mappings};
+
+    #[test]
+    fn every_mapping_is_an_action_in_order() {
+        let names: Vec<&str> = Action::ALL.iter().map(|a| a.name()).collect();
+        let mappings: Vec<&str> = MAPPINGS.iter().map(|m| m.0).collect();
+        assert_eq!(names[..mappings.len()], mappings[..]);
+        let horizon: Vec<&str> = HORIZON_MAPPINGS.iter().map(|m| m.0).collect();
+        let end = mappings.len() + horizon.len();
+        assert_eq!(names[mappings.len()..end], horizon[..]);
+        for action in &names[end..] {
+            assert!(action.starts_with("pad."), "{action}");
+        }
+    }
+
+    #[test]
+    fn an_actions_key_is_its_mappings_default_key() {
+        for (name, _, category) in all_mappings() {
+            let action = Action::parse(name).unwrap();
+            let want = if *category == "debug" {
+                None
+            } else {
+                keybinds::key_code(KeyBinds::default_of(name))
+            };
+            assert_eq!(action.key(), want, "{name}");
+        }
+    }
+
+    #[test]
+    fn every_bindable_action_is_an_action() {
+        for (name, _) in crate::gamepad::ACTIONS {
+            assert!(Action::parse(name).is_some(), "{name}");
+        }
+    }
+}
@@ -0,0 +1,182 @@
+//! The keys a player's mappings hold, as their vanilla default keys, and which
+//! devices hold each one. A key stays held while any device holds it, so one
+//! device letting go (splitscreen moving the keyboard to another player, say)
+//! can't release what another still presses.
+
+use crate::actions::Action;
+use std::collections::HashMap;
+use winit::keyboard::KeyCode;
+
+/// Where a press came from.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Source {
+    /// The keyboard and mouse.
+    Keyboard,
+    Pad,
+    /// `horizon-ctl`'s `key` and `mouse` and the agent commands that walk and click.
+    Agent,
+}
+
+impl Source {
+    fn bit(self) -> u8 {
+        match self {
+            Source::Keyboard => 1,
+            Source::Pad => 2,
+            Source::Agent => 4,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct HeldKeys {
+    held: HashMap<KeyCode, u8>,
+}
+
+impl HeldKeys {
+    /// Whether anything holds this mapping: every device, whatever the mapping is bound to.
+    pub fn held(&self, action: Action) -> bool {
+        action.key().is_some_and(|key| self.raw(&key))
+    }
+    /// Whether a key that is no mapping's default is held (Right Shift, the arrows, Alt, the system
+    /// key), or the key a caller already holds as a key: most code wants [`HeldKeys::held`].
+    pub fn raw(&self, key: &KeyCode) -> bool {
+        self.held.contains_key(key)
+    }
+    /// The old way of asking, by a mapping's default key; clippy refuses it (`clippy.toml`). It
+    /// stays so that a change written against it says what to use instead.
+    pub fn contains(&self, key: &KeyCode) -> bool {
+        self.raw(key)
+    }
+    /// `source` holds `key`. True when nothing held it before.
+    pub fn press(&mut self, key: KeyCode, source: Source) -> bool {
+        let sources = self.held.entry(key).or_insert(0);
+        let new = *sources == 0;
+        *sources |= source.bit();
+        new
+    }
+    /// `source` lets go of `key`. True when nothing holds it any more.
+    pub fn release(&mut self, key: &KeyCode, source: Source) -> bool {
+        let Some(sources) = self.held.get_mut(key) else {
+            return true;
+        };
+        *sources &= !source.bit();
+        if *sources == 0 {
+            self.held.remove(key);
+            true
+        } else {
+            false
+        }
+    }
+    pub fn held_by(&self, key: &KeyCode, source: Source) -> bool {
+        self.held
+            .get(key)
+            .is_some_and(|sources| sources & source.bit() != 0)
+    }
+    /// `source` lets go of everything: the keys nothing holds any more.
+    pub fn release_source(&mut self, source: Source) -> Vec<KeyCode> {
+        let keys: Vec<KeyCode> = self
+            .held
+            .iter()
+            .filter(|(_, sources)| *sources & source.bit() != 0)
+            .map(|(key, _)| *key)
+            .collect();
+        keys.into_iter()
+            .filter(|key| self.release(key, source))
+            .collect()
+    }
+    /// Held, by the keyboard unless a device already holds it: for callers
+    /// that don't say where the press came from.
+    pub fn insert(&mut self, key: KeyCode) -> bool {
+        if self.raw(&key) {
+            return false;
+        }
+        self.press(key, Source::Keyboard)
+    }
+    /// Let go of `key` whoever holds it.
+    pub fn remove(&mut self, key: &KeyCode) -> bool {
+        self.held.remove(key).is_some()
+    }
+    pub fn clear(&mut self) {
+        self.held.clear();
+    }
+    pub fn is_empty(&self) -> bool {
+        self.held.is_empty()
+    }
+    pub fn len(&self) -> usize {
+        self.held.len()
+    }
+    pub fn iter(&self) -> impl Iterator<Item = &KeyCode> {
+        self.held.keys()
+    }
+}
+
+impl IntoIterator for HeldKeys {
+    type Item = KeyCode;
+    type IntoIter = std::collections::hash_map::IntoKeys<KeyCode, u8>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.held.into_keys()
+    }
+}
+
+impl<'a> IntoIterator for &'a HeldKeys {
+    type Item = &'a KeyCode;
+    type IntoIter = std::collections::hash_map::Keys<'a, KeyCode, u8>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.held.keys()
+    }
+}
+
+impl FromIterator<KeyCode> for HeldKeys {
+    fn from_iter<I: IntoIterator<Item = KeyCode>>(keys: I) -> Self {
+        let mut held = HeldKeys::default();
+        for key in keys {
+            held.insert(key);
+        }
+        held
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_key_stays_held_while_any_device_holds_it() {
+        let mut keys = HeldKeys::default();
+        assert!(keys.press(KeyCode::Space, Source::Pad));
+        assert!(!keys.press(KeyCode::Space, Source::Keyboard));
+        assert!(keys.press(KeyCode::KeyW, Source::Keyboard));
+        assert_eq!(keys.release_source(Source::Keyboard), vec![KeyCode::KeyW]);
+        assert!(keys.held(Action::Jump) && !keys.held(Action::Forward));
+        assert!(keys.held_by(&KeyCode::Space, Source::Pad));
+        assert!(!keys.held_by(&KeyCode::Space, Source::Keyboard));
+        assert!(keys.release(&KeyCode::Space, Source::Pad));
+        assert!(keys.is_empty());
+    }
+
+    #[test]
+    fn a_script_holds_a_key_by_itself() {
+        let mut keys = HeldKeys::default();
+        keys.press(KeyCode::KeyW, Source::Agent);
+        keys.press(KeyCode::KeyW, Source::Keyboard);
+        assert!(!keys.release(&KeyCode::KeyW, Source::Keyboard));
+        assert!(keys.held(Action::Forward));
+        assert!(keys.release_source(Source::Pad).is_empty());
+        assert_eq!(keys.release_source(Source::Agent), vec![KeyCode::KeyW]);
+        assert!(!keys.held(Action::Forward));
+    }
+
+    #[test]
+    fn untagged_inserts_and_removes_act_as_before() {
+        let mut keys = HeldKeys::default();
+        keys.press(KeyCode::ShiftLeft, Source::Pad);
+        assert!(!keys.insert(KeyCode::ShiftLeft), "already held");
+        assert!(!keys.held_by(&KeyCode::ShiftLeft, Source::Keyboard));
+        assert!(
+            keys.remove(&KeyCode::ShiftLeft),
+            "remove lets go for everyone"
+        );
+        assert!(!keys.held(Action::Sneak));
+        assert!(keys.release(&KeyCode::KeyA, Source::Keyboard), "never held");
+    }
+}
@@ -51,11 +51,6 @@ impl InteractionInput {
    pub fn press(&mut self, button: Button) {
        self.clicks[button as usize] += 1;
    }
-    /// Whether a click waits for the next tick.
-    pub fn has_clicks(&self) -> bool {
-        self.clicks.iter().any(|&c| c > 0)
-    }
-
    pub fn tick(&mut self, world: &mut impl InteractionWorld, attack_down: bool, use_down: bool) {
        let [attack, use_item, pick] = std::mem::take(&mut self.clicks);
        world.pick_hit_result();
@@ -74,6 +74,17 @@ pub const MAPPINGS: &[(&str, &str, &str)] = &[
    ("key.debug.lightmapTexture", "key.keyboard.4", "debug"),
    ("key.debug.improvedTransparency", "key.keyboard.x", "debug"),
 ];
+/// Horizon's own key mappings: bound in Controls like the vanilla ones, but kept in
+/// `horizon-extras.txt` (`emoteKey`), never in `options.txt`, which stays exactly vanilla's
+/// (`MAPPINGS` is what the options parity harness compares with the pinned client).
+pub const HORIZON_MAPPINGS: &[(&str, &str, &str)] = &[
+    // The emote wheel (docs/cosmetics.md), on a key vanilla leaves free.
+    ("key.emote", "key.keyboard.b", "multiplayer"),
+];
+/// Every mapping the game binds: vanilla's in `Options.keyMappings` order, then Horizon's.
+pub fn all_mappings() -> impl Iterator<Item = &'static (&'static str, &'static str, &'static str)> {
+    MAPPINGS.iter().chain(HORIZON_MAPPINGS)
+}
 /// Mappings Options builds as `ToggleKeyMapping` (hold or toggle by option).
 pub fn is_toggle(name: &str) -> bool {
    matches!(name, "key.sneak" | "key.sprint" | "key.use" | "key.attack")
@@ -312,8 +323,7 @@ pub struct KeyBinds {
 impl Default for KeyBinds {
    fn default() -> Self {
        Self {
-            keys: MAPPINGS
-                .iter()
+            keys: all_mappings()
                .map(|(n, d, _)| (*n, (*d).to_owned()))
                .collect(),
        }
@@ -339,8 +349,7 @@ impl KeyBinds {
            .map_or("key.keyboard.unknown", String::as_str)
    }
    pub fn default_of(name: &str) -> &'static str {
-        MAPPINGS
-            .iter()
+        all_mappings()
            .find(|m| m.0 == name)
            .map_or("key.keyboard.unknown", |m| m.1)
    }
@@ -348,16 +357,24 @@ impl KeyBinds {
        self.get(name) == Self::default_of(name)
    }
    pub fn set(&mut self, name: &str, key: &str) {
-        if let Some((n, _, _)) = MAPPINGS.iter().find(|m| m.0 == name) {
+        if let Some((n, _, _)) = all_mappings().find(|m| m.0 == name) {
            self.keys.insert(n, key.to_owned());
        }
    }
+    /// The bindings `options.txt` holds: vanilla's mappings only.
    pub fn saved(&self) -> Vec<(&'static str, String)> {
        MAPPINGS
            .iter()
            .map(|(n, _, _)| (*n, self.get(n).to_owned()))
            .collect()
    }
+    /// Horizon's own bindings, for `horizon-extras.txt`.
+    pub fn horizon_saved(&self) -> Vec<(&'static str, String)> {
+        HORIZON_MAPPINGS
+            .iter()
+            .map(|(n, _, _)| (*n, self.get(n).to_owned()))
+            .collect()
+    }
    pub fn reset_all(&mut self) {
        *self = Self::default();
    }
@@ -367,8 +384,7 @@ impl KeyBinds {
        if key == "key.keyboard.unknown" {
            return Vec::new();
        }
-        MAPPINGS
-            .iter()
+        all_mappings()
            .filter(|(n, _, _)| {
                *n != name && self.get(n) == key && (!self.is_default(n) || !self.is_default(name))
            })
@@ -382,8 +398,7 @@ impl KeyBinds {
    /// Every mapping a physical input triggers, in list order: like
    /// `KeyMapping.set`/`click`, one key drives all the mappings bound to it.
    pub fn mappings_for<'a>(&'a self, key: &'a str) -> impl Iterator<Item = &'static str> + 'a {
-        MAPPINGS
-            .iter()
+        all_mappings()
            .map(|m| m.0)
            .filter(move |n| self.get(n) == key)
    }
@@ -393,8 +408,7 @@ impl KeyBinds {
    /// key and the binding itself); their defaults (A, S, D, T, L, 1 to 4...)
    /// would otherwise turn the key back into its old gameplay meaning.
    fn translated_mappings<'a>(&'a self, key: &'a str) -> impl Iterator<Item = &'static str> + 'a {
-        MAPPINGS
-            .iter()
+        all_mappings()
            .filter(|m| m.2 != "debug")
            .map(|m| m.0)
            .filter(move |n| self.get(n) == key)
@@ -402,9 +416,7 @@ impl KeyBinds {
    /// Whether a mapping (other than a debug key) whose default is `key` was
    /// bound elsewhere.
    fn default_moved(&self, key: &str) -> bool {
-        MAPPINGS
-            .iter()
-            .any(|(n, d, c)| *d == key && *c != "debug" && !self.is_default(n))
+        all_mappings().any(|(n, d, c)| *d == key && *c != "debug" && !self.is_default(n))
    }
    /// Translate a physical key into the default key of the mapping it is
    /// bound to, so game code written against vanilla defaults follows the
@@ -440,6 +452,18 @@ impl KeyBinds {
        }
        vec![Ok(key)]
    }
+    /// `Minecraft.handleKeybinds`: key.pickItem and key.spectatorHotbar share the middle button by
+    /// default and are separate mappings, so a press of what `input` is bound to acts only as the
+    /// one this player can use: the spectator hotbar for a spectator, pick block otherwise. (Pick
+    /// block does nothing a spectator would see.)
+    pub fn middle_acts(&self, input: &str, spectator: bool) -> bool {
+        let mapping = if spectator {
+            "key.spectatorHotbar"
+        } else {
+            "key.pickItem"
+        };
+        self.get(mapping) == input
+    }
    /// Translate a mouse button the same way (keys bound to mouse buttons).
    pub fn translate_mouse(&self, button: MouseButton) -> Option<Result<KeyCode, MouseButton>> {
        self.translate_mouse_all(button).into_iter().next()
@@ -503,6 +527,27 @@ impl KeyBinds {
 #[cfg(test)]
 mod tests {
    use super::*;
+
+    #[test]
+    fn mappings_sharing_the_middle_button_act_as_themselves() {
+        let middle = "key.mouse.middle";
+        let z = "key.keyboard.z";
+        let mut keys = KeyBinds::default();
+        assert!(keys.middle_acts(middle, false) && keys.middle_acts(middle, true));
+        // The spectator hotbar on Z: the middle button only picks, and Z never picks.
+        keys.set("key.spectatorHotbar", z);
+        assert!(keys.middle_acts(middle, false));
+        assert!(!keys.middle_acts(middle, true));
+        assert!(keys.middle_acts(z, true));
+        assert!(!keys.middle_acts(z, false));
+        // Pick block on Z instead: the other way round.
+        keys.reset_all();
+        keys.set("key.pickItem", z);
+        assert!(keys.middle_acts(z, false));
+        assert!(!keys.middle_acts(z, true));
+        assert!(keys.middle_acts(middle, true));
+        assert!(!keys.middle_acts(middle, false));
+    }
    #[test]
    fn container_mouse_hotkeys_follow_slot_bindings_and_pick_item_priority() {
        for button in [MouseButton::Back, MouseButton::Forward, MouseButton::Middle] {
@@ -3,8 +3,10 @@
 //! options. horizon-client re-exports each module under its old path
 //! (`horizon_client::keybinds`, ...).
 #![forbid(unsafe_code)]
+pub mod actions;
 pub mod clipboard;
 pub mod gamepad;
+pub mod held;
 pub mod input;
 pub mod interaction_input;
 pub mod key_names;
@@ -12,4 +14,5 @@ pub mod keybinds;
 pub mod keymapping;
 pub mod modifiers;
 pub mod mouse;
+pub mod snap;
 pub mod window;
@@ -0,0 +1,202 @@
+//! Where the controller's menu cursor settles once the stick is let go, and
+//! how it gets there. Every rule's number lives in [`Tuning`], so the feel can
+//! be adjusted in one place.
+
+/// The snapping engine's knobs, in GUI pixels and seconds.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Tuning {
+    /// A let-go cursor settles on a target this close to it.
+    pub radius: f32,
+    /// How long the glide onto a target takes.
+    pub glide_seconds: f32,
+    /// Movement shorter than this is a wobble: the cursor stays where it was.
+    pub min_travel: f32,
+    /// A flick that ends still nearest its starting target commits to the
+    /// neighbour it was heading for once it covered this fraction of the way.
+    pub commit: f32,
+    /// How far off the flick's direction a neighbour may lie (cosine of the
+    /// angle: 0.7 is about 45 degrees).
+    pub cone: f32,
+    /// The pointer's speed over a slot or control, as a fraction of its
+    /// speed elsewhere (1 leaves it unchanged).
+    pub over_target_speed: f32,
+}
+
+pub const TUNING: Tuning = Tuning {
+    radius: 16.0,
+    glide_seconds: 0.025,
+    min_travel: 1.5,
+    commit: 0.15,
+    cone: 0.7,
+    over_target_speed: 1.0,
+};
+
+type Point = (f32, f32);
+
+fn distance(a: Point, b: Point) -> f32 {
+    ((a.0 - b.0).powi(2) + (a.1 - b.1).powi(2)).sqrt()
+}
+
+/// The target nearest `at`, if one lies within `radius`.
+pub fn nearest(at: Point, targets: &[Point], radius: f32) -> Option<usize> {
+    targets
+        .iter()
+        .enumerate()
+        .map(|(i, t)| (i, distance(at, *t)))
+        .filter(|(_, d)| *d <= radius)
+        .min_by(|a, b| a.1.total_cmp(&b.1))
+        .map(|(i, _)| i)
+}
+
+/// Where a stick movement from `start` to `end` settles among `targets`
+/// (their centres), or `None` to leave the cursor where it is.
+pub fn settle(start: Point, end: Point, targets: &[Point], tuning: &Tuning) -> Option<usize> {
+    let near = nearest(end, targets, tuning.radius);
+    let travel = (end.0 - start.0, end.1 - start.1);
+    let length = distance(start, end);
+    if length < tuning.min_travel {
+        return near;
+    }
+    let origin = nearest(start, targets, tuning.radius);
+    if near != origin {
+        return near;
+    }
+    // Still nearest where it started: a quick flick toward a neighbour.
+    let Some(o) = origin else {
+        return near;
+    };
+    let from = targets[o];
+    let heading = (travel.0 / length, travel.1 / length);
+    let next = targets
+        .iter()
+        .enumerate()
+        .filter(|(i, _)| *i != o)
+        .filter_map(|(i, t)| {
+            let to = (t.0 - from.0, t.1 - from.1);
+            let gap = distance(from, *t);
+            let aligned = (to.0 * heading.0 + to.1 * heading.1) / gap;
+            (gap > 0.0 && aligned >= tuning.cone).then_some((i, gap, to))
+        })
+        .min_by(|a, b| a.1.total_cmp(&b.1));
+    match next {
+        Some((i, gap, to)) => {
+            let progress = ((end.0 - from.0) * to.0 + (end.1 - from.1) * to.1) / (gap * gap);
+            if progress >= tuning.commit {
+                Some(i)
+            } else {
+                near
+            }
+        }
+        None => near,
+    }
+}
+
+/// 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 {
+    let t = (seconds / tuning.glide_seconds).clamp(0.0, 1.0);
+    let eased = 1.0 - (1.0 - t).powi(3);
+    (
+        from.0 + (to.0 - from.0) * eased,
+        from.1 + (to.1 - from.1) * eased,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// 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.
+        assert_eq!(settle((8.0, 8.0), (12.0, 8.0), &SLOTS, &TUNING), Some(1));
+        assert_eq!(settle((8.0, 8.0), (8.0, 12.0), &SLOTS, &TUNING), Some(3));
+        assert_eq!(settle((26.0, 8.0), (22.0, 8.0), &SLOTS, &TUNING), Some(0));
+    }
+
+    #[test]
+    fn a_wobble_stays_put() {
+        assert_eq!(settle((8.0, 8.0), (8.5, 8.4), &SLOTS, &TUNING), Some(0));
+        // Barely started toward the neighbour: not committed.
+        assert_eq!(settle((8.0, 8.0), (9.6, 8.0), &SLOTS, &TUNING), Some(0));
+    }
+
+    #[test]
+    fn a_long_move_settles_on_the_nearest_target() {
+        assert_eq!(settle((8.0, 8.0), (42.0, 9.0), &SLOTS, &TUNING), Some(2));
+        // Far from everything: left where it is.
+        assert_eq!(settle((8.0, 8.0), (200.0, 200.0), &SLOTS, &TUNING), None);
+    }
+
+    #[test]
+    fn a_flick_off_any_row_does_not_jump_sideways() {
+        // Up from slot 0: nothing lies that way, so it stays on slot 0.
+        assert_eq!(settle((8.0, 8.0), (8.0, 4.0), &SLOTS, &TUNING), Some(0));
+    }
+
+    #[test]
+    fn the_glide_eases_onto_its_target_and_stops_there() {
+        let (from, to) = ((0.0, 0.0), (20.0, -10.0));
+        assert_eq!(glide(from, to, 0.0, &TUNING), from);
+        let half = glide(from, to, TUNING.glide_seconds / 2.0, &TUNING);
+        assert!(
+            half.0 > 10.0 && half.0 < 20.0,
+            "eased out: past halfway at half time"
+        );
+        assert_eq!(glide(from, to, TUNING.glide_seconds, &TUNING), to);
+        assert_eq!(glide(from, to, 1.0, &TUNING), to);
+    }
+}
@@ -393,19 +393,38 @@ impl FullscreenState {
        let reapply = self.set_exclusive(exclusive);
        self.set_preferred_mode(preferred);
        let mode_change = !in_video_screen && self.take_mode_change();
-        match request {
-            Some(false) => window.set_fullscreen(None),
-            Some(true) => window.set_fullscreen(Some(fullscreen_request(
+        if wanted && window.is_maximized() {
+            window.set_maximized(false);
+            window.set_fullscreen(Some(fullscreen_request(
                window,
                exclusive,
                preferred.as_ref(),
-            ))),
-            None if reapply || mode_change => window.set_fullscreen(Some(fullscreen_request(
-                window,
-                exclusive,
-                preferred.as_ref(),
-            ))),
-            None => {}
+            )));
+        } else {
+            match request {
+                Some(false) => window.set_fullscreen(None),
+                Some(true) => {
+                    if window.is_maximized() {
+                        window.set_maximized(false);
+                    }
+                    window.set_fullscreen(Some(fullscreen_request(
+                        window,
+                        exclusive,
+                        preferred.as_ref(),
+                    )));
+                }
+                None if reapply || mode_change => {
+                    if window.is_maximized() {
+                        window.set_maximized(false);
+                    }
+                    window.set_fullscreen(Some(fullscreen_request(
+                        window,
+                        exclusive,
+                        preferred.as_ref(),
+                    )));
+                }
+                None => {}
+            }
        }
    }

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

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

+/// Apply Horizon's icon to every window. Windows has a separate taskbar icon slot from the small
+/// window icon; requiring the decoded icon there prevents a generic taskbar icon from appearing.
+pub fn with_horizon_icon(
+    attributes: winit::window::WindowAttributes,
+) -> winit::window::WindowAttributes {
+    let icon = icon();
+    #[cfg(target_os = "windows")]
+    let icon = Some(icon.expect("Horizon's icon must be available on Windows"));
+
+    let attributes = attributes.with_window_icon(icon.clone());
+    #[cfg(target_os = "windows")]
+    let attributes =
+        winit::platform::windows::WindowAttributesExtWindows::with_taskbar_icon(attributes, icon);
+    attributes
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -18,6 +18,8 @@ horizon-client-core = { path = "../horizon-client-core" }
 horizon-client-input = { path = "../horizon-client-input" }
 horizon-client-render = { path = "../horizon-client-render" }
 horizon-command = { path = "../horizon-command" }
+# Emotes pose the player model (`Mob::emote`, `mobs::anim::setup`).
+horizon-cosmetics = { path = "../horizon-cosmetics" }
 horizon-items = { path = "../horizon-items" }
 horizon-core = { path = "../horizon-core" }
 # `horizon-ctl mcp`: the Model Context Protocol, shared with the launcher and the server.
@@ -30,6 +32,8 @@ horizon-world = { path = "../horizon-world" }
 horizon-protocol = { path = "../horizon-protocol" }
 # server.properties, eula.txt and the user lists, shared with horizon-server.
 horizon-server-files = { path = "../horizon-server-files" }
+# The control endpoint's token (control.rs), as horizon-server's and the relay's.
+getrandom = "0.3"
 # The dedicated server's anticheat, off unless server.toml's [anticheat] turns it on (docs/anticheat.md).
 horizon-anticheat = { path = "../horizon-anticheat" }
 # The dedicated server's chat filter: [chat_filter], the slur list, mutes (docs/chat-filter.md).
@@ -66,9 +66,10 @@ fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
        false,
        false,
        true,
+        false,
    ))?;
    assert!(!renderer.pack_entity_shadows(), "no selected pack");
-    renderer.set_shader_pack(0, None, &[]);
+    renderer.set_shader_pack(0, None, &[]).unwrap();
    assert!(
        !renderer.pack_entity_shadows(),
        "selected pack without a compiled post"
@@ -165,6 +166,7 @@ fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
            }
            let (_, notes) = renderer
                .set_shader_pack(dimension, Some(post), &[])
+                .unwrap()
                .unwrap();
            if break_pipeline {
                assert!(
@@ -190,8 +190,9 @@ fn replay(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
    }
    let one = [255u8; 4];
    let zero = [0u8; 4];
+    let pixels = render.pixels.get();
    let prepared = PreparedTextures::new(
-        &render.pixels,
+        &pixels,
        render.sprite_size,
        render.texture_layers,
        &render.sprite_mips,
@@ -206,7 +207,7 @@ fn replay(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
    let mut renderer = pollster::block_on(Renderer::new(
        window,
        true,
-        &render.pixels,
+        &pixels,
        render.sprite_size,
        render.sprite_minimum_size,
        render.texture_layers,
@@ -223,7 +224,10 @@ fn replay(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
        settings.translucent_batching,
        false,
        false,
+        false,
    ))?;
+    drop(pixels);
+    render.pixels.pack();
    let state = &scene.renderer;
    let [width, height] = o.size.unwrap_or(state.size);
    renderer.resize(width, height);
@@ -645,6 +649,7 @@ fn remesh(
                        nether_shading: false,
                        shader_pack_lighting: false,
                        separate_ao: false,
+                        shader_pack: false,
                        assets,
                        render,
                        tables: &tables,
@@ -79,7 +79,10 @@ fn pack(renderer: &mut Renderer, folder: &Path, valid: bool) {
    let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
    let post = horizon_shaders::load_post(&pack, "", &properties, &macros, &renderer.pack_inputs());
    assert_eq!(post.notes.is_empty(), valid, "{:?}", post.notes);
-    let (_, notes) = renderer.set_shader_pack(0, Some(post), &[]).unwrap();
+    let (_, notes) = renderer
+        .set_shader_pack(0, Some(post), &[])
+        .unwrap()
+        .unwrap();
    assert!(
        !valid || notes.iter().all(|n| !n.contains("skipped")),
        "{notes:?}"
@@ -123,6 +126,7 @@ fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
        false,
        false,
        true,
+        false,
    ))?;
    renderer.resize(320, 180);
    assert!(
@@ -352,6 +356,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: &[],
@@ -364,6 +369,7 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        visible_static_block_entity_sections: &[],
        static_block_entity_stats: Default::default(),
        entity_motion: &[],
+        entity_motion_posed: &[],
        entity_spans: &[],
        skin: None,
        glowing: &[],
@@ -374,10 +380,12 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
        lightning: Default::default(),
        additive: &[],
        see_through: &[],
+        world_primitives: Default::default(),
        shadow_only: &[],
        celestial: &[],
        stars: None,
        hand: &[],
+        hand_items: &[],
        hand_fov_degrees: 70.0,
        screen: &[],
        pack: Default::default(),
@@ -6,13 +6,7 @@ use horizon_world::{
    worldgen::{tags::TagDefinitions, terrain::TerrainBlockStates},
 };
 use serde_json::Value;
-use std::{
-    collections::BTreeSet,
-    fs::File,
-    io::{self, BufReader},
-    path::Path,
-    sync::Arc,
-};
+use std::{collections::BTreeSet, io, path::Path, sync::Arc};

 pub const MATERIALS: [&str; 6] = ["bedrock", "dirt", "stone", "sand", "oak_planks", "bricks"];
 #[derive(Clone, Copy)]
@@ -84,7 +78,9 @@ pub struct Assets {
 pub struct RenderAssets {
    pub sprite_size: u32,
    pub sprite_minimum_size: u32,
-    pub pixels: Vec<u8>,
+    /// The block sprites' RGBA, layer by layer: as built until a renderer has
+    /// them, then kept compressed ([`SpritePixels`]).
+    pub pixels: SpritePixels,
    pub texture_layers: u32,
    pub model_catalog: crate::models::StateModels,
    /// Shared parsed resources; item-only validation errors surface at item preparation.
@@ -111,6 +107,76 @@ pub struct RenderAssets {
    /// sprites are when it changes (`native_block_sprites_version`).
    pub generation: u64,
 }
+/// The block sprites' pixels for a renderer to upload. Once a renderer has
+/// them ([`Self::pack`]) they are kept lz4-compressed: the GPU holds the
+/// texture array, and the copy only serves a renderer made again (another
+/// window, a lost device, another graphics API), which waits for
+/// [`Self::get`] to uncompress them. Shared by the window and the workers'
+/// `RenderAssets`, so the compressed form replaces the raw one in place.
+pub struct SpritePixels(Arc<PixelStore>);
+struct PixelStore {
+    len: usize,
+    /// Set by the first `pack`: later calls cost one atomic read.
+    packing: std::sync::atomic::AtomicBool,
+    /// As built; dropped once `packed` holds them.
+    raw: std::sync::Mutex<Option<Arc<Vec<u8>>>>,
+    packed: std::sync::OnceLock<Vec<u8>>,
+}
+impl SpritePixels {
+    pub fn new(pixels: Vec<u8>) -> Self {
+        Self(Arc::new(PixelStore {
+            len: pixels.len(),
+            packing: std::sync::atomic::AtomicBool::new(false),
+            raw: std::sync::Mutex::new(Some(Arc::new(pixels))),
+            packed: std::sync::OnceLock::new(),
+        }))
+    }
+    /// Their size in bytes, uncompressed.
+    pub fn len(&self) -> usize {
+        self.0.len
+    }
+    pub fn is_empty(&self) -> bool {
+        self.0.len == 0
+    }
+    /// The pixels as built, uncompressed again once packed.
+    pub fn get(&self) -> Arc<Vec<u8>> {
+        let raw = self.0.raw.lock().unwrap_or_else(|e| e.into_inner()).clone();
+        raw.unwrap_or_else(|| {
+            let packed = self.0.packed.get().map(Vec::as_slice).unwrap_or_default();
+            Arc::new(
+                lz4_flex::decompress_size_prepended(packed)
+                    .ok()
+                    .filter(|p| p.len() == self.0.len)
+                    .unwrap_or_else(|| vec![0; self.0.len]),
+            )
+        })
+    }
+    /// Keep them compressed from now on, once a renderer has uploaded them:
+    /// compressed on a thread of their own, the raw copy dropped after.
+    pub fn pack(&self) {
+        use std::sync::atomic::Ordering;
+        if self.0.len == 0 || self.0.packing.swap(true, Ordering::Relaxed) {
+            return;
+        }
+        let store = self.0.clone();
+        let job = move || {
+            let raw = store.raw.lock().unwrap_or_else(|e| e.into_inner()).clone();
+            if let Some(raw) = raw {
+                let _ = store.packed.set(lz4_flex::compress_prepend_size(&raw));
+                // `get` reads the compressed copy from here on.
+                *store.raw.lock().unwrap_or_else(|e| e.into_inner()) = None;
+            }
+        };
+        let fallback = job.clone();
+        if std::thread::Builder::new()
+            .name("Sprite packing".into())
+            .spawn(job)
+            .is_err()
+        {
+            fallback();
+        }
+    }
+}
 /// The last `RenderAssets::generation` handed out.
 static GENERATION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
 fn invalid(message: &str) -> io::Error {
@@ -118,15 +184,12 @@ fn invalid(message: &str) -> io::Error {
 }
 impl Assets {
    pub fn load(root: &Path) -> Result<Self> {
-        let manifest: Value = serde_json::from_reader(BufReader::new(File::open(
-            root.join("horizon-resources.json"),
-        )?))?;
+        let manifest: Value = horizon_world::json_file::read(&root.join("horizon-resources.json"))?;
        if manifest["data_version"].as_i64() != Some(i64::from(DATA_VERSION)) {
            return Err(invalid("resources do not match Horizon's pinned data version").into());
        }
        let (registry, flags) = horizon_world::level::data::load_registry_with_flags(root)?;
-        let bundle: Value =
-            serde_json::from_reader(BufReader::new(File::open(root.join("block-tags.json"))?))?;
+        let bundle: Value = horizon_world::json_file::read(&root.join("block-tags.json"))?;
        let mut definitions = TagDefinitions::default();
        for (name, text) in bundle
            .as_object()
@@ -280,6 +343,7 @@ impl RenderAssets {
        }
        for stage in 0..10 {
            sprites.insert(root, &format!("minecraft:block/destroy_stage_{stage}"))?;
+            sprites.insert(root, &format!("minecraft:block/destroy_oit_stage_{stage}"))?;
        }
        let fusion = if draws {
            let _step = crate::spans::startup::step("core.fusion");
@@ -333,7 +397,7 @@ impl RenderAssets {
            sprite_size: sprites.size,
            sprite_minimum_size: sprites.minimum_size,
            texture_layers: u32::try_from(sprites.count())?,
-            pixels: sprites.pixels,
+            pixels: SpritePixels::new(sprites.pixels),
            model_catalog: models.catalog,
            model_library,
            model_placements: models.placements,
@@ -431,4 +495,29 @@ mod tests {
            [ConsumeEffect::ApplyEffects { probability, .. }] if probability == 0.3
        ));
    }
+
+    #[test]
+    fn sprite_pixels_come_back_the_same_once_packed() {
+        // Two layers of 16x16 RGBA with some structure, as sprites have.
+        let pixels: Vec<u8> = (0..2 * 16 * 16 * 4).map(|i| (i * 7 % 251) as u8).collect();
+        let stored = super::SpritePixels::new(pixels.clone());
+        assert_eq!(*stored.get(), pixels);
+        stored.pack();
+        stored.pack();
+        // The packing thread drops the raw copy once the compressed one is set.
+        let started = std::time::Instant::now();
+        while stored.0.raw.lock().unwrap().is_some() {
+            assert!(started.elapsed().as_secs() < 10, "packing never finished");
+            std::thread::yield_now();
+        }
+        assert!(
+            stored
+                .0
+                .packed
+                .get()
+                .is_some_and(|p| p.len() < pixels.len())
+        );
+        assert_eq!(*stored.get(), pixels);
+        assert_eq!(stored.len(), pixels.len());
+    }
 }
@@ -2,7 +2,9 @@
 //! small mixer standing in for OpenAL: one channel per source with its gain,
 //! pitch, linear distance attenuation (`AL_LINEAR_DISTANCE`, reference 0,
 //! rolloff 1), looping, relative flag and source state, Ogg/Vorbis decoding
-//! (streams on a worker thread) and OpenAL Soft's stereo panning.
+//! (streams on a worker thread) and OpenAL Soft's mixing: mono sources panned
+//! and attenuated, multi-channel buffers (stereo music and records) played
+//! direct as OpenAL does.
 use crate::Result;
 use crate::sound_engine::{
    Attenuation, Backend, Bound, ChannelId, InstanceId, PlayResult, SoundEngine, SoundInstance,
@@ -29,7 +31,7 @@ enum State {
 }
 /// An OpenAL source.
 struct Channel {
-    samples: Option<(Arc<Vec<f32>>, u32)>,
+    samples: Option<(Arc<Vec<f32>>, u32, u16)>,
    position: f64,
    state: State,
    gain: f32,
@@ -135,8 +137,8 @@ impl Drop for MixerBackend {
 static SHARED_CHANNELS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
 /// Two players' copies of one sound: started within this of each other.
 const SAME_SOUND: std::time::Duration = std::time::Duration::from_millis(150);
-/// Decoded samples and their rate (`None`: the file did not load).
-type Samples = Option<(Arc<Vec<f32>>, u32)>;
+/// Decoded interleaved samples, their rate and channel count (`None`: the file did not load).
+type Samples = Option<(Arc<Vec<f32>>, u32, u16)>;
 /// Decoded static sounds (`SoundBufferLibrary`'s buffers), dropped least
 /// recently used first past `CACHE_BYTES`: kept forever, every sound heard in
 /// a session stayed (up to 1.4 GiB of samples, villages playing hundreds).
@@ -177,7 +179,7 @@ impl SoundCache {
    fn size(samples: &Samples) -> usize {
        samples
            .as_ref()
-            .map_or(0, |(s, _)| s.len() * std::mem::size_of::<f32>())
+            .map_or(0, |(s, _, _)| s.len() * std::mem::size_of::<f32>())
    }
 }
 /// A static sound to decode for a channel waiting on it.
@@ -208,6 +210,18 @@ fn attach(mixer: &Mutex<Mixer>, channel: ChannelId, samples: Samples, looping: b
 type Stream = cpal::Stream;
 #[cfg(not(feature = "audio"))]
 type Stream = std::convert::Infallible;
+/// A level sound retained for the network broadcaster, in playback order.
+#[derive(Clone, Debug)]
+pub struct CapturedSound {
+    pub event: String,
+    pub position: [f64; 3],
+    pub volume: f32,
+    pub pitch: f32,
+    pub source: usize,
+    pub entity: Option<u32>,
+    pub except_entity: Option<u32>,
+}
+
 pub struct Audio {
    _stream: Option<Stream>,
    device_name: String,
@@ -224,7 +238,7 @@ pub struct Audio {
    source_override: Option<usize>,
    /// Positional sounds played since the last drain, kept while the world
    /// is open to the network so guests hear them too.
-    pub capture: Option<Vec<(String, [f64; 3], f32, f32)>>,
+    pub capture: Option<Vec<CapturedSound>>,
    /// How many times each positional sound played (the control socket's `status`),
    /// with or without an audio device.
    pub heard: std::collections::BTreeMap<String, u32>,
@@ -248,7 +262,7 @@ pub struct Audio {
    #[cfg(feature = "audio")]
    device_ticks: u32,
 }
-fn decode(path: &Path) -> Option<(Vec<f32>, u32)> {
+fn decode(path: &Path) -> Option<(Vec<f32>, u32, u16)> {
    use symphonia::core::{
        audio::SampleBuffer, codecs::DecoderOptions, formats::FormatOptions, io::MediaSourceStream,
        meta::MetadataOptions, probe::Hint,
@@ -272,7 +286,8 @@ fn decode(path: &Path) -> Option<(Vec<f32>, u32)> {
    let mut decoder = symphonia::default::get_codecs()
        .make(&track.codec_params, &DecoderOptions::default())
        .ok()?;
-    let mut mono = Vec::new();
+    let mut samples = Vec::new();
+    let mut channels = 0u16;
    while let Ok(packet) = format.next_packet() {
        if packet.track_id() != id {
            continue;
@@ -281,14 +296,34 @@ fn decode(path: &Path) -> Option<(Vec<f32>, u32)> {
            continue;
        };
        let spec = *buffer.spec();
-        let channels = spec.channels.count().max(1);
-        let mut samples = SampleBuffer::<f32>::new(buffer.capacity() as u64, spec);
-        samples.copy_interleaved_ref(buffer);
-        for frame in samples.samples().chunks(channels) {
-            mono.push(frame.iter().sum::<f32>() / channels as f32);
+        let frame_channels = spec.channels.count().max(1);
+        let mut decoded = SampleBuffer::<f32>::new(buffer.capacity() as u64, spec);
+        decoded.copy_interleaved_ref(buffer);
+        if channels == 0 {
+            channels = frame_channels.min(2) as u16;
+        }
+        if frame_channels <= 2 {
+            samples.extend_from_slice(decoded.samples());
+        } else {
+            // OpenAL plays multi-channel buffers direct; a stereo output hears the odd/even split.
+            for frame in decoded.samples().chunks(frame_channels) {
+                let (mut left, mut right) = (0.0, 0.0);
+                let (mut lefts, mut rights) = (0.0f32, 0.0f32);
+                for (i, sample) in frame.iter().enumerate() {
+                    if i % 2 == 0 {
+                        left += sample;
+                        lefts += 1.0;
+                    } else {
+                        right += sample;
+                        rights += 1.0;
+                    }
+                }
+                samples.push(left / lefts.max(1.0));
+                samples.push(right / rights.max(1.0));
+            }
        }
    }
-    Some((mono, rate))
+    (channels != 0).then_some((samples, rate, channels))
 }
 /// A sound file without its variant number (`mob/creeper/say2.ogg` is `mob/creeper/say`): each
 /// player's game picks its own variant of the same event.
@@ -415,7 +450,7 @@ impl Backend for MixerBackend {
            // A streamed sound loops by restarting its stream.
            let mixer = self.mixer.clone();
            std::thread::spawn(move || {
-                let samples = decode(&file).map(|(s, r)| (Arc::new(s), r));
+                let samples = decode(&file).map(|(s, r, c)| (Arc::new(s), r, c));
                attach(&mixer, channel, samples, looping);
            });
            return;
@@ -436,7 +471,7 @@ impl Backend for MixerBackend {
                        // Queued twice before the first decode finished.
                        let cached = cache.lock().ok().and_then(|mut c| c.get(&job.key));
                        let samples = cached.unwrap_or_else(|| {
-                            let samples = decode(&job.file).map(|(s, r)| (Arc::new(s), r));
+                            let samples = decode(&job.file).map(|(s, r, c)| (Arc::new(s), r, c));
                            if let Ok(mut c) = cache.lock() {
                                c.insert(job.key, samples.clone());
                            }
@@ -572,9 +607,13 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
    let mut voices = std::mem::take(&mut mixer.voices);
    voices.clear();
    for (id, c) in &mixer.channels {
-        let Some((_, source_rate)) = &c.samples else {
+        let Some((_, source_rate, source_channels)) = &c.samples else {
            continue;
        };
+        // OpenAL plays a multi-channel buffer direct: no panning and no distance attenuation
+        // (`CalcVoiceParams`' non-spatialized path, vanilla's HRTF-off stereo context). Vanilla's
+        // music and records are stereo. A mono buffer is the positional one.
+        let direct = *source_channels > 1;
        if c.state != State::Playing {
            continue;
        }
@@ -599,24 +638,33 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
        let d = if c.relative { at } else { away(listener) };
        let distance = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt() as f32;
        let gain = if camera.is_some() {
-            c.gain.clamp(0.0, 1.0) * distance_gain(c.linear, distance)
+            c.gain.clamp(0.0, 1.0)
+                * if direct {
+                    1.0
+                } else {
+                    distance_gain(c.linear, distance)
+                }
        } else {
            0.0
        };
-        // Relative sources are already in OpenAL's listener space (-Z ahead).
-        let [mut left, mut right] = if c.relative {
-            stereo_gains(d[0] as f32, d[1] as f32, -d[2] as f32)
+        let [left, right] = if direct {
+            [gain, gain]
        } else {
-            stereo_gains(dot(d, right), dot(d, up), dot(d, forward))
+            // Relative sources are already in OpenAL's listener space (-Z ahead).
+            let [mut left, mut right] = if c.relative {
+                stereo_gains(d[0] as f32, d[1] as f32, -d[2] as f32)
+            } else {
+                stereo_gains(dot(d, right), dot(d, up), dot(d, forward))
+            };
+            if shared {
+                // Several players on the speakers: half the stereo width, as left and right are
+                // nobody's in particular.
+                let middle = (left + right) / 2.0;
+                left = middle + (left - middle) / 2.0;
+                right = middle + (right - middle) / 2.0;
+            }
+            [left * gain, right * gain]
        };
-        if shared {
-            // Several players on the speakers: half the stereo width, as left and right are
-            // nobody's in particular.
-            let middle = (left + right) / 2.0;
-            left = middle + (left - middle) / 2.0;
-            right = middle + (right - middle) / 2.0;
-        }
-        let [left, right] = [left, right].map(|pan| gain * pan);
        let step = f64::from(*source_rate) / f64::from(rate) * f64::from(c.pitch.max(0.0));
        voices.push((*id, [left, right, gain], step));
    }
@@ -624,13 +672,15 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
        let Some(c) = mixer.channels.get_mut(&id) else {
            continue;
        };
-        let Some((samples, _)) = c.samples.clone() else {
+        let Some((samples, _, source_channels)) = c.samples.clone() else {
            continue;
        };
+        let source_channels = source_channels as usize;
+        let frames = samples.len() / source_channels;
        for frame in data.chunks_mut(channels) {
            let mut i = c.position as usize;
-            if i + 1 >= samples.len() {
-                if c.looping && samples.len() > 1 {
+            if i + 1 >= frames {
+                if c.looping && frames > 1 {
                    c.position = 0.0;
                    i = 0;
                } else {
@@ -639,13 +689,24 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
                }
            }
            let t = (c.position - i as f64) as f32;
-            let s = samples[i] * (1.0 - t) + samples[i + 1] * t;
-            if channels >= 2 {
-                frame[0] += s * left;
-                frame[1] += s * right;
+            if source_channels > 1 {
+                let l = samples[i * 2] * (1.0 - t) + samples[(i + 1) * 2] * t;
+                let r = samples[i * 2 + 1] * (1.0 - t) + samples[(i + 1) * 2 + 1] * t;
+                if channels >= 2 {
+                    frame[0] += l * left;
+                    frame[1] += r * right;
+                } else {
+                    frame[0] += (l + r) * 0.5 * gain;
+                }
            } else {
-                // A mono output has no panning: the source's own gain.
-                frame[0] += s * gain;
+                let s = samples[i] * (1.0 - t) + samples[i + 1] * t;
+                if channels >= 2 {
+                    frame[0] += s * left;
+                    frame[1] += s * right;
+                } else {
+                    // A mono output has no panning: the source's own gain.
+                    frame[0] += s * gain;
+                }
            }
            c.position += step;
        }
@@ -693,17 +754,27 @@ fn open_device(
 ) -> Result<(cpal::Stream, cpal::SupportedStreamConfig)> {
    use cpal::SampleFormat as F;
    let config = device.default_output_config()?;
-    let stream = match config.sample_format() {
-        F::F32 => build_stream::<f32>(device, &config, mixer.clone()),
-        F::F64 => build_stream::<f64>(device, &config, mixer.clone()),
-        F::I16 => build_stream::<i16>(device, &config, mixer.clone()),
-        F::I32 => build_stream::<i32>(device, &config, mixer.clone()),
-        F::I8 => build_stream::<i8>(device, &config, mixer.clone()),
-        F::U16 => build_stream::<u16>(device, &config, mixer.clone()),
-        F::U32 => build_stream::<u32>(device, &config, mixer.clone()),
-        F::U8 => build_stream::<u8>(device, &config, mixer.clone()),
+    let build = |stream_config: &cpal::StreamConfig| match config.sample_format() {
+        F::F32 => build_stream::<f32>(device, &config, stream_config, mixer.clone()),
+        F::F64 => build_stream::<f64>(device, &config, stream_config, mixer.clone()),
+        F::I16 => build_stream::<i16>(device, &config, stream_config, mixer.clone()),
+        F::I32 => build_stream::<i32>(device, &config, stream_config, mixer.clone()),
+        F::I8 => build_stream::<i8>(device, &config, stream_config, mixer.clone()),
+        F::U16 => build_stream::<u16>(device, &config, stream_config, mixer.clone()),
+        F::U32 => build_stream::<u32>(device, &config, stream_config, mixer.clone()),
+        F::U8 => build_stream::<u8>(device, &config, stream_config, mixer.clone()),
        other => Err(format!("unsupported sample format {other}").into()),
-    }?;
+    };
+    let short = audio_stream_config(&config);
+    let stream = match build(&short) {
+        Ok(stream) => stream,
+        // A device that refuses the short fixed buffer still plays with cpal's default one.
+        Err(e) if short != config.config() => {
+            log::info!("Horizon: audio output refused a short buffer ({e}); using the default");
+            build(&config.config())?
+        }
+        Err(e) => return Err(e),
+    };
    stream.play()?;
    if let Ok(mut m) = mixer.lock() {
        m.device_name = device.name().unwrap_or_default();
@@ -784,10 +855,58 @@ fn cards_changed(seen: Option<&str>, cards: Option<&str>) -> bool {
        _ => true,
    }
 }
+
+/// The buffer size to request for `open_device`. On Linux the ALSA backend's
+/// `BufferSize::Default` means a ~100 ms buffer, so sound effects come out
+/// about 100 ms late: request a short fixed buffer (1024 frames) by default.
+/// An environment override `HORIZON_AUDIO_BUFFER` can specify `default` or a
+/// custom frame count (e.g. 2048) when the default short buffer underruns
+/// (e.g. PipeWire min-quantum >= 1024).
+#[cfg(feature = "audio")]
+fn target_buffer_size(
+    range: (u32, u32),
+    var: impl Fn(&str) -> Option<std::ffi::OsString>,
+) -> Option<cpal::BufferSize> {
+    if let Some(val) = var("HORIZON_AUDIO_BUFFER").and_then(|v| v.into_string().ok()) {
+        if val == "default" {
+            return Some(cpal::BufferSize::Default);
+        }
+        if let Ok(frames) = val.parse::<u32>() {
+            return Some(cpal::BufferSize::Fixed(frames.clamp(range.0, range.1)));
+        }
+    }
+    #[cfg(target_os = "linux")]
+    {
+        Some(cpal::BufferSize::Fixed(1024u32.clamp(range.0, range.1)))
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        None
+    }
+}
+
+/// The cpal `StreamConfig` to open an output stream with. On Linux the ALSA
+/// backend's `BufferSize::Default` means a ~100 ms buffer, so sound effects
+/// come out about 100 ms late: request a short fixed buffer there. Other
+/// platforms keep cpal's default behaviour.
+#[cfg(feature = "audio")]
+fn audio_stream_config(config: &cpal::SupportedStreamConfig) -> cpal::StreamConfig {
+    let mut sc = config.config();
+    let range = match config.buffer_size() {
+        cpal::SupportedBufferSize::Range { min, max } => (*min, *max),
+        cpal::SupportedBufferSize::Unknown => (256, 4096),
+    };
+    if let Some(bs) = target_buffer_size(range, |name| std::env::var_os(name)) {
+        sc.buffer_size = bs;
+    }
+    sc
+}
+
 #[cfg(feature = "audio")]
 fn build_stream<T: cpal::SizedSample + cpal::FromSample<f32>>(
    device: &cpal::Device,
    config: &cpal::SupportedStreamConfig,
+    stream_config: &cpal::StreamConfig,
    mixer: Arc<Mutex<Mixer>>,
 ) -> Result<cpal::Stream> {
    let rate = config.sample_rate().0;
@@ -795,7 +914,7 @@ fn build_stream<T: cpal::SizedSample + cpal::FromSample<f32>>(
    let mut scratch = Vec::new();
    let on_error = mixer.clone();
    let stream = device.build_output_stream(
-        &config.config(),
+        stream_config,
        move |data: &mut [T], _| {
            scratch.resize(data.len(), 0.0f32);
            if let Ok(mut m) = mixer.lock() {
@@ -1262,7 +1381,17 @@ impl Audio {
    pub fn play_after(&mut self, event: &str, at: [f64; 3], volume: f32, pitch: f32, ticks: i32) {
        let seed = self.random.next_long();
        if let Some(capture) = self.capture.as_mut() {
-            capture.push((event.to_owned(), at, volume, pitch));
+            capture.push(CapturedSound {
+                event: event.to_owned(),
+                position: at,
+                volume,
+                pitch,
+                source: self.source_override.unwrap_or_else(|| {
+                    crate::settings::sound_source(&crate::sound_events::normalize(event))
+                }),
+                entity: None,
+                except_entity: None,
+            });
        }
        *self.heard.entry(event.to_owned()).or_default() += 1;
        self.sync_volumes();
@@ -1301,6 +1430,66 @@ impl Audio {
        preview.preview(self, source, volume);
        self.preview = preview;
    }
+    /// An incoming entity-sound packet: retain its seed and category without rebroadcasting it.
+    pub fn play_entity_seeded(
+        &mut self,
+        event: &str,
+        source: usize,
+        volume: f32,
+        pitch: f32,
+        seed: i64,
+        entity: crate::sound_engine::SoundEntity,
+    ) {
+        *self.heard.entry(event.to_owned()).or_default() += 1;
+        let event = crate::sound_events::normalize(event);
+        let instance = SoundInstance::entity_bound(
+            &event,
+            source,
+            volume,
+            pitch,
+            LegacyRandom::new(seed),
+            entity,
+        );
+        self.play_instance(instance, false);
+    }
+    /// A level's entity overload: preserve the emitter and excluded player for
+    /// the server broadcaster while the local sound follows the same object.
+    pub fn play_bound(
+        &mut self,
+        event: &str,
+        source: usize,
+        volume: f32,
+        pitch: f32,
+        entity: crate::sound_engine::SoundEntity,
+        except_entity: Option<u32>,
+    ) {
+        if let Some(capture) = self.capture.as_mut() {
+            capture.push(CapturedSound {
+                event: event.to_owned(),
+                position: entity.state().position,
+                volume,
+                pitch,
+                source,
+                entity: Some(entity.id),
+                except_entity,
+            });
+        }
+        let seed = self.random.next_long();
+        self.play_entity_seeded(event, source, volume, pitch, seed, entity);
+    }
+    /// Removal belongs to the old object even if its numeric id is immediately reused.
+    pub fn remove_sound_entity(&mut self, id: u32) {
+        for entity in self
+            .engine
+            .bound_entities()
+            .into_iter()
+            .filter(|e| e.id == id)
+        {
+            let mut state = entity.state();
+            state.removed = true;
+            entity.update(state);
+        }
+    }
    /// `play` with the seed a sound packet carries.
    pub fn play_seeded(
        &mut self,
@@ -1311,7 +1500,17 @@ impl Audio {
        seed: i64,
    ) {
        if let (Some(capture), Some(at)) = (self.capture.as_mut(), at) {
-            capture.push((event.to_owned(), at, volume, pitch));
+            capture.push(CapturedSound {
+                event: event.to_owned(),
+                position: at,
+                volume,
+                pitch,
+                source: self.source_override.unwrap_or_else(|| {
+                    crate::settings::sound_source(&crate::sound_events::normalize(event))
+                }),
+                entity: None,
+                except_entity: None,
+            });
        }
        if at.is_some() {
            *self.heard.entry(event.to_owned()).or_default() += 1;
@@ -1451,6 +1650,81 @@ impl Sounds for Audio {
 mod tests {
    use super::*;

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

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

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

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

 /// A structure or test instance block: the block entities whose box the frame may draw.
@@ -229,6 +230,7 @@ impl BlockEntities {
    }
    /// `removeBlockEntityTicker`: no slot, made or pending.
    fn cancel(&mut self, pos: &Pos) {
+        self.asleep.remove(pos);
        self.freed |= self.live.remove(pos).is_some();
        self.pending.remove(pos);
    }
@@ -297,14 +299,25 @@ impl BlockEntities {
        self.map.get(pos)
    }
    pub fn get_mut(&mut self, pos: &Pos) -> Option<&mut BlockEntity> {
+        self.asleep.remove(pos);
        self.map.get_mut(pos)
    }
    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&Pos, &mut BlockEntity)> {
+        self.asleep.clear();
        self.map.iter_mut()
    }
    pub fn values_mut(&mut self) -> impl Iterator<Item = &mut BlockEntity> {
+        self.asleep.clear();
        self.map.values_mut()
    }
+    pub fn sleep(&mut self, pos: Pos) {
+        if self.map.contains_key(&pos) {
+            self.asleep.insert(pos);
+        }
+    }
+    pub fn is_asleep(&self, pos: &Pos) -> bool {
+        self.asleep.contains(pos)
+    }
    /// `LevelChunk.setBlockEntity` (+ `addAndRegisterBlockEntity`): a new
    /// block entity may get a slot; one replacing another keeps its slot.
    /// One of the same type rewrites it in place (a jukebox taking a disc,
@@ -320,6 +333,7 @@ impl BlockEntities {
            self.attachments.remove(&pos);
        }
        let new_box = shows_box(&entity);
+        self.asleep.remove(&pos);
        let old = self.map.insert(pos, entity);
        if old.is_none() {
            self.add(pos);
@@ -346,6 +360,7 @@ impl BlockEntities {
        if absent {
            self.add(pos);
        }
+        self.asleep.remove(&pos);
        let entity = self.map.entry(pos).or_insert_with(make);
        if absent && matches!(entity, BlockEntity::Mod(_)) {
            self.mods.entry(chunk_of(pos)).or_default().insert(pos);
@@ -358,6 +373,7 @@ impl BlockEntities {
    /// `LevelChunk.removeBlockEntity`: the block entity and its slot.
    pub fn remove(&mut self, pos: &Pos) -> Option<BlockEntity> {
        self.attachments.remove(pos);
+        self.asleep.remove(pos);
        self.cancel(pos);
        let removed = self.map.remove(pos);
        if matches!(removed, Some(BlockEntity::Mod(_))) {
@@ -369,6 +385,7 @@ impl BlockEntities {
    /// The block entity at `pos`, out of the map for a while: its slot stays
    /// for `put` to bring it back (a tick working on it).
    pub fn take(&mut self, pos: &Pos) -> Option<BlockEntity> {
+        self.asleep.remove(pos);
        let taken = self.map.remove(pos);
        if taken.is_some() {
            self.out.insert(*pos);
@@ -378,6 +395,7 @@ impl BlockEntities {
    /// Brings back what `take` took, in its slot.
    pub fn put(&mut self, pos: Pos, entity: BlockEntity) {
        self.out.remove(&pos);
+        self.asleep.remove(&pos);
        if matches!(entity, BlockEntity::Mod(_)) {
            self.mods.entry(chunk_of(pos)).or_default().insert(pos);
        }
@@ -389,6 +407,16 @@ impl BlockEntities {
            self.add(pos);
        }
    }
+    /// [`Self::retain`] for unloading chunks: removes the block entities at
+    /// the positions `gone` names and changes none it keeps, so those that
+    /// sleep stay asleep (a moving player unloads chunks most ticks).
+    pub fn unload(&mut self, mut gone: impl FnMut(&Pos) -> bool) {
+        let asleep = std::mem::take(&mut self.asleep);
+        self.retain(|p, _| !gone(p));
+        self.asleep = asleep;
+        let map = &self.map;
+        self.asleep.retain(|p| map.contains_key(p));
+    }
    /// Removes the block entities `keep` refuses, and their slots
    /// (`clearAllBlockEntities` of unloaded chunks).
    pub fn retain(&mut self, mut keep: impl FnMut(&Pos, &mut BlockEntity) -> bool) {
@@ -399,6 +427,7 @@ impl BlockEntities {
            &mut self.attachments,
        );
        let (mods, boxes) = (&mut self.mods, &mut self.boxes);
+        self.asleep.clear();
        self.map.retain(|p, e| {
            let kept = keep(p, e);
            if !kept {
@@ -416,6 +445,7 @@ impl BlockEntities {
        self.map.clear();
        self.mods.clear();
        self.boxes.clear();
+        self.asleep.clear();
        self.tickers = Arc::default();
        self.live.clear();
        self.added.clear();
@@ -433,6 +463,7 @@ impl BlockEntities {
        let order = chunk_map_order(entities.iter().map(|(p, _)| *p));
        for (p, e) in entities {
            self.attachments.remove(&p);
+            self.asleep.remove(&p);
            let new_is_mod = matches!(e, BlockEntity::Mod(_));
            self.note_box(p, Some(&e));
            let old = self.map.insert(p, e);
@@ -452,6 +483,7 @@ impl BlockEntities {
    /// `LevelChunk.setBlockState` on a block entity's position, from state
    /// `old` to `new`: a ticker made, kept or dropped.
    pub fn state_changed(&mut self, pos: Pos, old: u32, new: u32) {
+        self.asleep.remove(&pos);
        if self.states.is_empty() || !self.map.contains_key(&pos) {
            return;
        }
@@ -506,6 +538,11 @@ impl BlockEntities {
        });
        Arc::clone(&self.tickers)
    }
+    /// How many block entities tick (`Level.blockEntityTickers`, the slots still live), as of
+    /// the last [`Self::tickers`]: what a diagnostics mod counts.
+    pub fn ticking_len(&self) -> usize {
+        self.live.len()
+    }
    /// Whether a slot from `tickers` still ticks.
    pub fn is_live(&self, (pos, slot): (Pos, u32)) -> bool {
        self.live.get(&pos) == Some(&slot) && self.map.contains_key(&pos)
@@ -536,12 +573,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());
@@ -939,6 +939,14 @@ impl BlockEntityAnims {
    /// Drops the state of block entities that are gone or changed kind:
    /// `present` holds the loaded block entities' tickers, sorted by position.
    pub fn retain_present(&mut self, present: &[([i32; 3], Ticker)]) {
+        self.retain_animations(present, false);
+    }
+    /// An integrated server owns bell state independently of renderer visibility.
+    /// Its world ticker removes bells when their actual block changes.
+    pub fn retain_present_preserving_bells(&mut self, present: &[([i32; 3], Ticker)]) {
+        self.retain_animations(present, true);
+    }
+    fn retain_animations(&mut self, present: &[([i32; 3], Ticker)], keep_bells: bool) {
        let is = |p: &[i32; 3], f: fn(&Ticker) -> bool| {
            present
                .binary_search_by_key(p, |(q, _)| *q)
@@ -948,7 +956,9 @@ impl BlockEntityAnims {
        self.books.retain(|p, _| is(p, |t| *t == Ticker::Book));
        self.shulkers
            .retain(|p, _| is(p, |t| matches!(t, Ticker::Shulker { .. })));
-        self.bells.retain(|p, _| is(p, |t| *t == Ticker::Bell));
+        if !keep_bells {
+            self.bells.retain(|p, _| is(p, |t| *t == Ticker::Bell));
+        }
        self.conduits
            .retain(|p, _| is(p, |t| *t == Ticker::Conduit));
        self.skulls
@@ -7,10 +7,11 @@
 //! 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,
+    font::Glyph,
    gfx::mark_oit,
    hud::Rect,
    mesher::{CULL_BACK, Vertex},
@@ -270,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))
@@ -638,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,
@@ -660,26 +663,54 @@ fn sign_text_calls(
    } else {
        (dark, 0, vertex_light(packed))
    };
-    let advance = |c: char| (scene.glyph)(c).1;
-    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 advance = |c: char| (scene.glyph)(c).advance;
+    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
@@ -695,14 +726,31 @@ 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 (cell, advance) = (scene.glyph)(ch);
-            if let Some(r) = cell {
-                let corners = [(x, y0 + 8.0), (x + 8.0, y0 + 8.0), (x + 8.0, y0), (x, y0)];
-                let uvs = [[r.u0, r.v1], [r.u1, r.v1], [r.u1, r.v0], [r.u0, r.v0]];
+            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).
+                let (x0, x1) = (x + g.left, x + g.right);
+                let (top, bottom) = (y0 + g.top, y0 + g.bottom);
+                let corners = [(x0, bottom), (x1, bottom), (x1, top), (x0, top)];
+                let uvs = [
+                    [cell.u0, cell.v1],
+                    [cell.u1, cell.v1],
+                    [cell.u1, cell.v0],
+                    [cell.u0, cell.v0],
+                ];
                let c =
                    0xFF00_0000 | (argb & 255) << 16 | (argb >> 8 & 255) << 8 | (argb >> 16 & 255);
                for ((cx, cy), uv) in corners.into_iter().zip(uvs) {
@@ -721,7 +769,7 @@ fn draw_text(scene: &Scene, call: &TextCall, out: &mut Vec<Vertex>) {
                    });
                }
            }
-            x += advance;
+            x += g.advance;
        }
    };
    if call.outline != 0 {
@@ -818,11 +866,14 @@ pub struct Scene<'a> {
    /// profile → skin): a downloaded `skins/<sha1>` slot or the profile's
    /// `DefaultPlayerSkin` fallback; None keeps `SKIN_BY_TYPE` (`DefaultPlayerSkin.getDefaultTexture`, slim steve).
    pub skull: &'a dyn Fn([i32; 3]) -> Option<String>,
-    /// Font glyph cell (none for blank glyphs such as the space) and advance.
-    pub glyph: &'a dyn Fn(char) -> (Option<Rect>, f32),
+    /// Font glyph: atlas cell (none for blank glyphs such as the space), box and advance.
+    pub glyph: &'a dyn Fn(char) -> Glyph,
    /// 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.
@@ -1392,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,
@@ -1401,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
@@ -1412,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;
@@ -1683,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;
                }
@@ -1698,6 +1931,7 @@ impl BlockEntityRenderer {
                        options,
                        &active_entries[index].1,
                        current_section_revision,
+                        chest_openness,
                    )
                {
                    let entry = &mut active_entries[index].1;
@@ -1717,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]))
@@ -1738,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 {
@@ -1761,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 {
@@ -1847,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,
@@ -1874,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);
            }
@@ -1940,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;
@@ -1957,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;
                }
@@ -3142,7 +3407,9 @@ impl BeamPart {
                (at(b, self.end), [s.u0, v1]),
            ] {
                out.push(Vertex {
-                    normal: [0; 4],
+                    // The beacon beam render types keep the default back-face culling: seen
+                    // from inside a beam, its walls must not show.
+                    normal: CULL_BACK,
                    pos: p.to_array(),
                    uv,
                    layer: 6,
@@ -3232,6 +3499,7 @@ fn portal_cube(m: Mat4, faces: &[Direction], layer: u32, out: &mut Vec<Vertex>)
 mod tests {
    use super::*;
    use crate::assets::Assets;
+    use horizon_world::nbt::Tag;
    #[test]
    #[ignore = "requires prepared models/textures in HORIZON_TEST_RESOURCES"]
    fn entity_block_particles_and_breaking_use_exported_models() -> Result<()> {
@@ -3342,8 +3610,9 @@ mod tests {
            sign: &|_| None,
            banner: &|_| Vec::new(),
            skull: &|_| None,
-            glyph: &|_| (None, 0.0),
+            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.
@@ -3610,7 +3879,13 @@ mod tests {
                w: 8,
                h: 8,
            };
-            (Some(rect), 6.0)
+            Glyph {
+                rect: Some(rect),
+                right: 8.0,
+                bottom: 8.0,
+                advance: 6.0,
+                ..Glyph::default()
+            }
        };
        let scene = Scene {
            camera: DVec3::ZERO,
@@ -3632,6 +3907,7 @@ mod tests {
            skull: &|_| None,
            glyph: &glyph,
            glyphs: 0,
+            dynamic_visible: None,
        };
        let mut call = TextCall {
            matrix: Mat4::IDENTITY,
@@ -3660,6 +3936,202 @@ mod tests {
        assert!(out.iter().all(|v| v.pos[2] == 0.0));
    }

+    /// BakedSheetGlyph draws a glyph over its own box from the pen
+    /// (x + left .. x + right, y + up .. y + down), not a fixed 8x8 cell. With
+    /// Force Unicode Font a Latin letter is an 8x16 Unifont glyph at half
+    /// scale: 4 units wide and 8 tall, advancing 5 (#8699).
+    #[test]
+    fn sign_text_draws_each_glyph_over_its_own_box() {
+        let world = World::new(BlockStateId(0), 1);
+        let sprites = HashMap::new();
+        let glyph = |_: char| Glyph {
+            rect: Some(Rect {
+                u0: 0.0,
+                v0: 0.0,
+                u1: 0.0625,
+                v1: 0.125,
+                w: 8,
+                h: 16,
+            }),
+            left: 0.0,
+            top: 0.0,
+            right: 4.0,
+            bottom: 8.0,
+            advance: 5.0,
+            offset: 0.5,
+        };
+        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,
+        };
+        let call = TextCall {
+            matrix: Mat4::IDENTITY,
+            x: 10.0,
+            y: 2.0,
+            text: "ab".into(),
+            color: 0xFF00_0000,
+            outline: 0,
+            light: 240 | 240 << 8,
+        };
+        let mut out = Vec::new();
+        draw_text(&scene, &call, &mut out);
+        let boxes: Vec<_> = out
+            .chunks(4)
+            .map(|q| {
+                let xs = q.iter().map(|v| v.pos[0]);
+                let ys = q.iter().map(|v| v.pos[1]);
+                [
+                    xs.clone().fold(f32::MAX, f32::min),
+                    xs.fold(f32::MIN, f32::max),
+                    ys.clone().fold(f32::MAX, f32::min),
+                    ys.fold(f32::MIN, f32::max),
+                ]
+            })
+            .collect();
+        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 {
@@ -3714,7 +4186,13 @@ mod tests {
                w: 8,
                h: 8,
            };
-            ((c != ' ').then_some(rect), wide.get())
+            Glyph {
+                rect: (c != ' ').then_some(rect),
+                right: 8.0,
+                bottom: 8.0,
+                advance: wide.get(),
+                ..Glyph::default()
+            }
        };
        let (first_sign, changed_sign, glowing_sign) = (
            |_| Some(&first_text),
@@ -3741,6 +4219,7 @@ mod tests {
            skull: &|_| None,
            glyph: &glyph,
            glyphs: 0,
+            dynamic_visible: None,
        };
        let check = |scene: &Scene, pos: [i32; 3], state: u32| {
            let mut cached = Vec::new();
@@ -3800,6 +4279,23 @@ mod tests {
    /// submits the unit cube's two Y faces. Both are wound outward, so of each
    /// face only the side looking at the camera draws: the portal shows one
    /// surface from above and one from below, never both at once.
+    /// `RenderPipelines.BEACON_BEAM_OPAQUE` / `_TRANSLUCENT` keep the default
+    /// back-face culling, so a camera inside a beam sees no wall of it.
+    #[test]
+    fn beacon_beam_faces_cull_their_backs() {
+        let rect = Rect {
+            u0: 0.0,
+            v0: 0.0,
+            u1: 1.0,
+            v1: 1.0,
+            w: 16,
+            h: 16,
+        };
+        let mut out = Vec::new();
+        beacon_beam(Vec3::ZERO, &[(0xFFFFFF, 4)], 0.0, 1.0, rect, &mut out);
+        assert_eq!(out.len(), 32, "solid and glow, four quads each");
+        assert!(out.iter().all(|v| v.normal == CULL_BACK));
+    }
    #[test]
    fn the_end_portal_cube_is_one_sided() {
        let mut out = Vec::new();
@@ -3879,8 +4375,9 @@ mod tests {
            sign: &|_| None,
            banner: &|_| Vec::new(),
            skull: &|_| None,
-            glyph: &|_| (None, 0.0),
+            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);
@@ -3964,8 +4461,9 @@ mod tests {
            sign: &|_| None,
            banner: &|_| Vec::new(),
            skull: &|_| None,
-            glyph: &|_| (None, 0.0),
+            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| {
@@ -4,6 +4,7 @@ use crate::{
        ModelPart, SIGN_TEXT_KEEP, Scene, StaticSectionRevision, classify,
    },
    chunk::Chunk,
+    font::Glyph,
    hud::Rect,
    mesher::Vertex,
    signs::{SignData, SignText},
@@ -355,8 +356,9 @@ fn batched_callbacks_preserve_entity_ranges_and_allow_immediate_culling() {
        sign: &|_| None,
        banner: &|_| Vec::new(),
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        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.
@@ -443,8 +445,9 @@ fn static_cache_qualifies_local_positions_by_section_and_drops_old_entries() {
        sign: &|_| None,
        banner: &|_| Vec::new(),
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let options = CacheOptions {
        shulker_boxes: true,
@@ -497,8 +500,9 @@ fn gpu_static_cache_uses_section_local_chests_and_keeps_visibility_separate() {
        sign: &|_| None,
        banner: &|_| Vec::new(),
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let blocks = [([100, 70, -32], 0)];
    let other_block = [([116, 70, -32], 0)];
@@ -651,18 +655,19 @@ fn sign_text_cache_can_be_disabled_and_reenabled_without_changing_output() {
    };
    let sign_data = &data;
    let sign = move |_: [i32; 3]| Some(sign_data);
-    let glyph = |_: char| {
-        (
-            Some(Rect {
-                u0: 0.0,
-                v0: 0.0,
-                u1: 0.0625,
-                v1: 0.0625,
-                w: 8,
-                h: 8,
-            }),
-            6.0,
-        )
+    let glyph = |_: char| Glyph {
+        rect: Some(Rect {
+            u0: 0.0,
+            v0: 0.0,
+            u1: 0.0625,
+            v1: 0.0625,
+            w: 8,
+            h: 8,
+        }),
+        right: 8.0,
+        bottom: 8.0,
+        advance: 6.0,
+        ..Glyph::default()
    };
    let scene = Scene {
        camera: DVec3::new(2.25, 64.5, -3.75),
@@ -684,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 {
@@ -735,8 +741,9 @@ fn shulker_cache_tracks_settled_poses_and_does_not_freeze_opening_animation() {
        sign: &|_| None,
        banner: &|_| Vec::new(),
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
    let options = CacheOptions {
@@ -836,8 +843,9 @@ fn shulker_cache_covers_all_colors_and_facing_directions() {
        sign: &|_| None,
        banner: &|_| Vec::new(),
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let options = CacheOptions {
        shulker_boxes: true,
@@ -890,8 +898,9 @@ fn cached_bells_keep_shaking_until_the_animation_ends() {
        sign: &|_| None,
        banner: &|_| Vec::new(),
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
    let options = CacheOptions {
@@ -951,8 +960,9 @@ fn cached_closed_chests_match_the_direct_model_and_rebuild_when_opening() {
        sign: &|_| None,
        banner: &|_| Vec::new(),
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
    let options = CacheOptions {
@@ -1046,8 +1056,9 @@ fn closed_chest_cache_covers_all_materials_and_atlas_reloads() {
        sign: &|_| None,
        banner: &|_| Vec::new(),
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let pos = [0, 64, 0];
    let options = CacheOptions {
@@ -1134,8 +1145,9 @@ fn double_chest_cache_bypasses_both_halves_while_either_lid_is_open() {
        sign: &|_| None,
        banner: &|_| Vec::new(),
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let pair = [([0, 64, 0], 0), ([1, 64, 0], 1)];
    let options = CacheOptions {
@@ -1209,8 +1221,9 @@ fn decorated_pot_cache_tracks_sherds_and_bypasses_wobble_animation() {
        sign: &|_| None,
        banner: &|_| Vec::new(),
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
    let options = CacheOptions {
@@ -1287,8 +1300,9 @@ fn banner_cache_keeps_the_pole_static_while_the_flag_and_patterns_update() {
        sign: &|_| None,
        banner: &banner_patterns,
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let blocks = [([0, 64, 0], 0)];
    let options = CacheOptions {
@@ -1353,8 +1367,9 @@ fn cached_wall_banner_poles_use_the_wall_model() {
        sign: &|_| None,
        banner: &|_| Vec::new(),
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let pos = [0, 64, 0];
    let options = CacheOptions {
@@ -1400,8 +1415,9 @@ fn copper_statue_cache_rebuilds_when_its_pose_state_changes() {
        sign: &|_| None,
        banner: &|_| Vec::new(),
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let options = CacheOptions {
        copper_golem_statues: true,
@@ -1505,8 +1521,9 @@ fn copper_statue_cache_covers_weathering_waxing_and_all_poses() {
        sign: &|_| None,
        banner: &|_| Vec::new(),
        skull: &|_| None,
-        glyph: &|_| (None, 0.0),
+        glyph: &|_| Glyph::default(),
        glyphs: 0,
+        dynamic_visible: None,
    };
    let options = CacheOptions {
        copper_golem_statues: true,
@@ -0,0 +1,249 @@
+//! Every block state's facts and looks by its id, for a client mod drawing blocks or a map off the main thread
+//! (`native_block_states`; docs/native-mods.md): what the game knows of each state, what its model draws on each side
+//! and the texture behind each of those sprites. A copy, so the game's own tables can change shape under it.
+use crate::{
+    block_sprites::{BlockSprites, Lookup, SpriteRef},
+    streaming::WorkerContext,
+};
+use horizon_items::blocks::{BlockFacts, MAP_COLORS, RenderShape};
+use horizon_world::{
+    block_collision::BlockCollisionRegistry, fluid::FluidState, registry::BlockStateId,
+};
+use std::{collections::HashMap, sync::Arc};
+
+/// What one block state is, as a renderer or a map reads it.
+#[derive(Clone, Debug, PartialEq)]
+#[non_exhaustive]
+pub struct BlockStateFacts {
+    /// Its block, without properties (`minecraft:grass_block`).
+    pub name: Arc<str>,
+    /// `BlockState.isAir`: air, cave air or void air.
+    pub air: bool,
+    /// No model draws it (render shape `INVISIBLE`): air, barriers, light, and water and lava, drawn as fluids.
+    pub invisible: bool,
+    /// `BlockState.getFluidState`: the fluid in it, a waterlogged block's and kelp's included; empty for none.
+    pub fluid: FluidState,
+    /// Its `waterlogged` property is true.
+    pub waterlogged: bool,
+    /// The light it gives, 0 to 15.
+    pub emission: u8,
+    /// `BlockState.getShape`, the outline the cursor picks, as block-local boxes
+    /// `[min_x, min_y, min_z, max_x, max_y, max_z]`: `[0, 0, 0, 1, 1, 1]` for a whole block, none for air. Without
+    /// the random offset of flowers and grass.
+    pub outline: Arc<[[f64; 6]]>,
+    /// `MapColor.col` (`0xRRGGBB`), its colour on a vanilla map; none for `MapColor.NONE`, which maps leave out.
+    pub map_color: Option<u32>,
+    /// It can collide at all: false for a state whose collision shape is always empty (air, flowers, water).
+    pub collides: bool,
+}
+
+// A mod builds its tables from these on a worker thread.
+const _: () = {
+    const fn shareable<T: Send + Sync + 'static>() {}
+    shareable::<BlockStates>()
+};
+
+/// Every block state by its id: its facts, and what its model draws with the resources loaded when it was made.
+#[derive(Clone)]
+pub struct BlockStates {
+    states: Arc<[BlockStateFacts]>,
+    context: Arc<WorkerContext>,
+    /// Texture names by sprite layer, across every array.
+    textures: Arc<HashMap<u32, String>>,
+    split: u32,
+}
+
+impl BlockStates {
+    /// The states of `context`'s registry, with their `facts` and `collision`, and the sprites of `context`'s
+    /// resources at `split` layers to an array (`Renderer::sprite_split`).
+    pub fn new(
+        facts: &BlockFacts,
+        collision: &BlockCollisionRegistry<'_>,
+        context: Arc<WorkerContext>,
+        split: u32,
+    ) -> Self {
+        let registry = context.assets.registry;
+        let states = facts
+            .states
+            .iter()
+            .enumerate()
+            .map(|(i, f)| {
+                let id = BlockStateId(i as u32);
+                BlockStateFacts {
+                    name: f.name.clone(),
+                    air: facts.is_air(id),
+                    invisible: f.render_shape == RenderShape::Invisible,
+                    fluid: registry
+                        .state(id)
+                        .and_then(|state| FluidState::from_block(state).ok())
+                        .unwrap_or(FluidState::EMPTY),
+                    waterlogged: f.waterlogged,
+                    emission: f.emission,
+                    outline: f.outline.clone(),
+                    map_color: MAP_COLORS
+                        .get(usize::from(f.map_color))
+                        .copied()
+                        .filter(|_| f.map_color != 0),
+                    collides: collision.may_collide(id),
+                }
+            })
+            .collect();
+        // Vanilla's names go without their namespace, as `native_draw_cube` takes them.
+        let textures = context
+            .render
+            .sprite_layers
+            .iter()
+            .map(|(name, layer)| (*layer, name.trim_start_matches("minecraft:").to_owned()))
+            .collect();
+        Self {
+            states,
+            context,
+            textures: Arc::new(textures),
+            split: split.max(1),
+        }
+    }
+
+    /// How many states there are: their ids run from 0 to one less.
+    pub fn len(&self) -> usize {
+        self.states.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.states.is_empty()
+    }
+
+    /// `state`'s facts; none for an id past the last state.
+    pub fn get(&self, state: BlockStateId) -> Option<&BlockStateFacts> {
+        self.states.get(state.0 as usize)
+    }
+
+    /// Every state with its id, in id order.
+    pub fn iter(&self) -> impl Iterator<Item = (BlockStateId, &BlockStateFacts)> {
+        self.states
+            .iter()
+            .enumerate()
+            .map(|(i, facts)| (BlockStateId(i as u32), facts))
+    }
+
+    /// What `state` draws on each side, as `native_block_sprites` says for a block by name; none for an id past the
+    /// last state.
+    pub fn sprites(&self, state: BlockStateId) -> Option<BlockSprites> {
+        self.get(state)?;
+        Some(Lookup::new(&self.context, self.split).state(state))
+    }
+
+    /// The texture `sprite` shows, by the name `native_texture_sprites` takes (`block/grass_block_top`; a mod's with
+    /// its namespace, `mymod:block/gear`).
+    pub fn texture(&self, sprite: SpriteRef) -> Option<&str> {
+        let layer = sprite
+            .array
+            .checked_mul(self.split)?
+            .checked_add(sprite.layer)?;
+        self.textures.get(&layer).map(String::as_str)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        assets::Assets, biome::Biomes, block_sprites::parse_state, light::LightTables,
+        mesher::MeshTables,
+    };
+    use horizon_assets::model::Direction;
+    use horizon_world::fluid::FluidKind;
+    use std::{path::PathBuf, sync::OnceLock};
+
+    /// Far fewer layers to an array than a GPU takes, so most sprites lie past array 0.
+    const SMALL_SPLIT: u32 = 64;
+
+    /// The game's own states from real prepared resources, loaded once for every test here.
+    fn states() -> &'static BlockStates {
+        static STATES: OnceLock<BlockStates> = OnceLock::new();
+        STATES.get_or_init(|| {
+            let root = PathBuf::from(
+                std::env::var_os("HORIZON_TEST_RESOURCES").expect("HORIZON_TEST_RESOURCES"),
+            );
+            let assets = Arc::new(Assets::load(&root).unwrap());
+            let render = Arc::new(assets.reload(&root).unwrap());
+            let facts = BlockFacts::load(&root, assets.registry).unwrap();
+            let collision = crate::collisions::load(&root, assets.registry).unwrap();
+            let visibility = crate::models::load_visibility(&root, assets.registry).unwrap();
+            let context = Arc::new(WorkerContext {
+                light: Arc::new(LightTables::load(&root, assets.registry, &facts).unwrap()),
+                tables: Arc::new(MeshTables::new(&assets, &render, &facts, visibility).unwrap()),
+                assets: assets.clone(),
+                render,
+                biomes: Arc::new(Biomes::load(&root).unwrap()),
+            });
+            BlockStates::new(&facts, &collision, context, SMALL_SPLIT)
+        })
+    }
+
+    fn facts(text: &str) -> &'static BlockStateFacts {
+        let states = states();
+        let id = parse_state(states.context.assets.registry, text).expect(text);
+        states.get(id).unwrap()
+    }
+
+    #[test]
+    #[ignore = "requires prepared resources in HORIZON_TEST_RESOURCES"]
+    fn a_grass_block_is_a_whole_solid_grass_coloured_block() {
+        let grass = facts("grass_block");
+        assert_eq!(&*grass.name, "minecraft:grass_block");
+        assert!(!grass.air && !grass.invisible && !grass.waterlogged);
+        assert_eq!(grass.fluid.kind(), FluidKind::Empty);
+        assert_eq!(grass.emission, 0);
+        assert_eq!(&*grass.outline, [[0.0, 0.0, 0.0, 1.0, 1.0, 1.0]]);
+        assert_eq!(grass.map_color, Some(0x7F_B238), "MapColor.GRASS");
+        assert!(grass.collides);
+    }
+
+    #[test]
+    #[ignore = "requires prepared resources in HORIZON_TEST_RESOURCES"]
+    fn air_and_light_are_not_drawn() {
+        let air = facts("air");
+        assert!(air.air && air.invisible && !air.collides);
+        assert!(air.outline.is_empty());
+        assert_eq!(air.map_color, None);
+        let light = facts("light[level=15]");
+        assert!(!light.air && light.invisible);
+        assert_eq!(light.emission, 15);
+    }
+
+    #[test]
+    #[ignore = "requires prepared resources in HORIZON_TEST_RESOURCES"]
+    fn a_slabs_outline_is_its_half() {
+        assert_eq!(
+            &*facts("stone_slab[type=bottom]").outline,
+            [[0.0, 0.0, 0.0, 1.0, 0.5, 1.0]]
+        );
+        assert_eq!(
+            &*facts("stone_slab[type=top]").outline,
+            [[0.0, 0.5, 0.0, 1.0, 1.0, 1.0]]
+        );
+        let wet = facts("stone_slab[type=bottom,waterlogged=true]");
+        assert!(wet.waterlogged && wet.collides);
+        assert_eq!(wet.fluid.kind(), FluidKind::Water);
+        assert!(wet.fluid.is_source());
+    }
+
+    #[test]
+    #[ignore = "requires prepared resources in HORIZON_TEST_RESOURCES"]
+    fn a_face_names_its_texture() {
+        let states = states();
+        let id = parse_state(states.context.assets.registry, "grass_block").unwrap();
+        let grass = states.sprites(id).unwrap();
+        let top = grass.sides[Direction::Up as usize][0].sprite;
+        assert_eq!(states.texture(top), Some("block/grass_block_top"));
+        let north = &grass.sides[Direction::North as usize];
+        assert_eq!(
+            states.texture(north[0].sprite),
+            Some("block/grass_block_side")
+        );
+        assert_eq!(
+            states.texture(north[1].sprite),
+            Some("block/grass_block_side_overlay")
+        );
+    }
+}
@@ -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");
+    }
 }