Merge main into feat/lua-mods (Cargo.toml members one per line; stability.md server-mods row from main)

Co-Authored-By: Claude Opus 5.5 <[email protected]>

.claude/skills/vanilla-parity/SKILL.md

@@ -1,76 +0,0 @@
----
-name: vanilla-parity
-description: Fix a Horizon bug or gap so it behaves 1:1 like vanilla 26.3, starting from the port ledger (tools/port_ledger.py) instead of grepping. Use for any issue, Discord report or PR that makes Horizon match vanilla: "X doesn't work like in Java", a missing sound, particle, animation, mob behaviour, block rule, screen or packet.
----
-
-# Vanilla parity with the port ledger
-
-The port ledger pairs every vanilla method with the Rust fn that ports it (or says it is missing, or needs
-no port) and lists where a port isn't wired like vanilla. Ask it first; grep only for what it can't answer.
-Full reference: `docs/port-ledger.md`.
-
-## 0. Have a fresh ledger
-
-```sh
-python3 tools/port_ledger.py build          # ~20 s; again after pulling main
-```
-
-It needs the vanilla jar (the launcher's `versions/26.3/26.3.jar`, or `--jar`) and/or the lab's decompiled
-sources (`python3 tools/lab.py decompile`, or `--sources DIR`). If `build` says it has no vanilla code, run
-the lab first; don't guess vanilla from memory.
-
-## 1. From the report to the code
-
-```sh
-python3 tools/port_ledger.py issue 3236                      # a GitHub issue number
-python3 tools/port_ledger.py issue "mooshroom stays red after lightning"   # or the report's text
-```
-
-It ranks the vanilla classes the report names and lists, per class, its Rust home files, where each method is
-ported, and the known gaps (`missing` rows from the verdict map, seam/client/drift gaps). Often the cause is
-already written there ("Type is not saved"). Then drill in:
-
-```sh
-python3 tools/port_ledger.py where MushroomCow.readAdditionalSaveData   # ports, callers, callees, gaps
-python3 tools/port_ledger.py class MushroomCow                          # every method: where, or missing
-python3 tools/port_ledger.py what crates/horizon-client/src/mobs/farm.rs:120   # which vanilla method a fn ports
-```
-
-A ledger answer is a lead, not a verdict: about 1 in 12 map rows is wrong. Read the vanilla method (path and
-line are in the output) and the Rust fn before changing anything.
-
-## 2. Port it the vanilla way
-
-- Translate the vanilla method, don't reinvent it: same order of operations, same constants, the same random
-  draws in the same order (`horizon_core::random`), Java `Math` through `horizon_core::jmath`.
-- Open the fn's doc with the vanilla method it ports: `` /// `MushroomCow.readAdditionalSaveData`: ... ``.
-  That one line is what makes the next agent find it.
-- Fix the path players run: single player is a client of the integrated server, so server logic lives in
-  `game/lan*.rs` and `src/lan/`, and what only the client's copy shows (particles, local sounds, hand
-  animation) must be reached from `game/remote*.rs`. A fix on the old in-frame path alone fixes nothing.
-- Look at the neighbours the ledger lists for the same class: a `client` or `seam` gap next to your fix is
-  usually the same bug on the other path.
-
-## 3. Before the PR
-
-```sh
-python3 tools/port_ledger.py check --base origin/main
-```
-
-It lists the ports your branch touches with their open gaps, citations to add, stale citations, and (against
-the base) the gaps the branch closes and opens. Close what belongs to your fix, cite what you ported, leave
-no new stale citation. If you ported a method the verdict map called `missing`, change its row in
-`tools/port_map/*.tsv` to `port` with the fn (`file.rs::Owner::fn`) and run
-`python3 tools/port_ledger.py map-check tools/port_map/<file>.tsv`.
-
-Then the usual: the harness for the area (`docs/architecture.md`), `cargo check`/tests per `AGENTS.md`, and
-a small PR that says which vanilla method it now matches.
-
-## Finding work
-
-```sh
-python3 tools/port_ledger.py gaps --kind seam      # ported on two paths, wired on one: the best leads
-python3 tools/port_ledger.py gaps --kind client    # client-only effects the server path never reaches
-python3 tools/port_ledger.py gaps --kind drift     # a port missing a sound, particle, item or constant
-rg -n "player:" tools/port_map/*.tsv               # missing behaviour a player would see
-```

.githooks/pre-commit

@@ -1,11 +1,2 @@
 #!/bin/sh
-# Git for Windows puts a `python3` on PATH that is only the Microsoft Store
-# stub: it prints "Python" and exits non-zero, so the hook fails with no other
-# output. Use the first name that actually runs Python 3.
-for py in python3 python py; do
-    if "$py" -c "import sys; sys.exit(sys.version_info < (3,))" >/dev/null 2>&1; then
-        exec "$py" tools/check_public_tree.py
-    fi
-done
-echo "check_public_tree: no working Python 3 found" >&2
-exit 1
+exec python3 tools/check_public_tree.py

.githooks/pre-push

@@ -1,11 +1,2 @@
 #!/bin/sh
-# Git for Windows puts a `python3` on PATH that is only the Microsoft Store
-# stub: it prints "Python" and exits non-zero, so the hook fails with no other
-# output. Use the first name that actually runs Python 3.
-for py in python3 python py; do
-    if "$py" -c "import sys; sys.exit(sys.version_info < (3,))" >/dev/null 2>&1; then
-        exec "$py" tools/check_public_tree.py --pre-push
-    fi
-done
-echo "check_public_tree: no working Python 3 found" >&2
-exit 1
+exec python3 tools/check_public_tree.py --pre-push

.github/pull_request_template.md

@@ -1,21 +1,7 @@
-<!-- Opened by an AI agent? First line: "> 🤖 Opened by <your GitHub login>'s AI agent (<tool, model>), not by <your GitHub login> personally." Use your own login, not someone else's. -->
-
 ## What and why
 
 <!-- What this changes, and why. Link the issue it fixes ("Fixes #123"). -->
 
-## Kind
-
-<!-- Tick one: it sets the pull request's label (CONTRIBUTING.md "Pull requests"). -->
-
-- [ ] parity: Horizon now does what vanilla 26.3 does
-- [ ] bug: a crash or a breakage
-- [ ] perf: faster, or less memory
-- [ ] feature: something new for players (listed under New in the release notes)
-- [ ] extra: Horizon-only, off by default
-- [ ] tooling: tools, CI, tests, harnesses
-- [ ] docs
-
 ## Vanilla reference
 
 <!-- The vanilla classes and methods this follows (tools/rea_vanilla.py), and the harness that checks it.

.github/trusted-reviewers.txt

@@ -1,9 +0,0 @@
-# Trusted reviewers: one list for two 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)

.github/workflows/cancel-on-close.yml

@@ -16,14 +16,12 @@ jobs:
           GH_TOKEN: ${{ github.token }}
           REPO: ${{ github.repository }}
           BRANCH: ${{ github.event.pull_request.head.ref }}
-          HEAD_REPO: ${{ github.event.pull_request.head.repo.full_name }}
+          SHA: ${{ github.event.pull_request.head.sha }}
         run: |
-          # Every head the pull request had, not only its last: a run-parity label added on an older head left that
-          # run queued after the merge (#3104, 2026-10-29). Its branch in its own repository names its runs (another
-          # fork can have a branch of the same name).
           for status in queued in_progress waiting pending requested; do
-            gh api -X GET "repos/$REPO/actions/runs" -f branch="$BRANCH" -f event=pull_request -f status="$status" \
-              -f per_page=100 --jq ".workflow_runs[] | select(.head_repository.full_name == \"$HEAD_REPO\") | .id"
+            gh run list -R "$REPO" --branch "$BRANCH" --status "$status" --limit 100 \
+              --json databaseId,event,headSha \
+              -q ".[] | select(.event == \"pull_request\" and .headSha == \"$SHA\") | .databaseId"
           done | sort -u | while read -r id; do
             gh run cancel -R "$REPO" "$id" || true
           done

.github/workflows/ci.yml

@@ -51,7 +51,7 @@ jobs:
         if: steps.rust.outputs.required != 'false'
         run: |
           sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
-          rustup toolchain install stable --profile minimal --component rustfmt --component clippy
+          rustup toolchain install stable --profile minimal --component rustfmt --component clippy --target wasm32-unknown-unknown
       # Dependencies and the workspace's own build, saved from main's runs (pull requests read main's cache).
       - uses: Swatinem/rust-cache@v2
         if: steps.rust.outputs.required != 'false'
@@ -62,7 +62,8 @@ jobs:
         if: steps.rust.outputs.required != 'false'
         run: |
           cargo +stable fmt --all -- --check
-          cargo +stable clippy --workspace --all-targets -- -D warnings
+          # With the game's code mods (on in every release build, off by default).
+          cargo +stable clippy --workspace --all-targets --features horizon-client/mods -- -D warnings
           # The server build (released as horizon-engine): the game without sound or controllers.
           cargo +stable clippy -p horizon-client --all-targets --no-default-features -- -D warnings
       # Libraries, binaries and integration tests, then doc tests: not the ~275 examples, which clippy above already
@@ -70,11 +71,11 @@ jobs:
       - name: Test Rust core and voxel kernel correctness
         if: steps.rust.outputs.required != 'false'
         run: |
-          cargo +stable test --workspace --lib --bins --tests
+          cargo +stable test --workspace --lib --bins --tests --features horizon-client/mods,horizon-mods/pack
           # The full content-root tests (#[ignore]d: minutes each on a laptop). The same build as above; they need the
           # prepared vanilla data, so without it they pass at once.
-          cargo +stable test --workspace --lib mod_content::tests:: -- --ignored
-          cargo +stable test --workspace --doc
+          cargo +stable test --workspace --lib --features horizon-client/mods,horizon-mods/pack mod_content::tests:: -- --ignored
+          cargo +stable test --workspace --doc --features horizon-client/mods,horizon-mods/pack
   # The launcher is its own workspace (launcher/Cargo.toml), so verify's cargo runs never build it. A pull request that
   # changes it or a crate it builds is checked here, and so is every push to main: two pull requests can each pass
   # alone and break it together (#2059 and the registry ratings did, 2026-10-26).

.github/workflows/claim-command.yml

@@ -1,76 +0,0 @@
-name: claim command
-# `/claim` and `/unclaim` comments: anyone takes an issue before working on it, and a daily run releases the claims
-# older than 5 days that no open pull request links (CONTRIBUTING.md "Claim before you start",
-# tools/ci/claim_command.py).
-#
-# Why no pull request's code runs here, though the token can write:
-# - `issue_comment` and `schedule` always run this file from main, whoever comments and wherever.
-# - It checks out main's script and list only, never a pull request; it reads threads through the API.
-# - The comment's text and author reach the script as env vars, never in a shell line. The token stays in the step
-#   and can only write issues (assignees, comments, reactions).
-on:
-  issue_comment:
-    types: [created]
-  schedule:
-    - cron: "23 5 * * *"
-  workflow_dispatch:
-permissions:
-  contents: read
-jobs:
-  command:
-    # Every other comment skips here, before a runner starts. Pull requests are answered by the script.
-    if: >-
-      github.event_name == 'issue_comment' && github.event.comment.user.type != 'Bot' && (
-      startsWith(github.event.comment.body, '/claim') ||
-      startsWith(github.event.comment.body, '/unclaim') ||
-      startsWith(github.event.comment.body, '🤖 Agent: /claim') ||
-      startsWith(github.event.comment.body, '🤖 Agent: /unclaim'))
-    # One command per issue at a time, so two `/claim`s can't both find it free. On the job, not the workflow:
-    # the skipped runs of ordinary comments must not cancel a waiting one.
-    concurrency:
-      group: claim-${{ github.event.issue.number }}
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    permissions:
-      contents: read
-      issues: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: main
-          persist-credentials: false
-          sparse-checkout: |
-            .github/trusted-reviewers.txt
-            tools/ci/nightly_set.py
-            tools/ci/claim_command.py
-          sparse-checkout-cone-mode: false
-      - name: Run the command
-        env:
-          GH_TOKEN: ${{ github.token }}
-          BODY: ${{ github.event.comment.body }}
-          AUTHOR: ${{ github.event.comment.user.login }}
-          ISSUE: ${{ github.event.issue.number }}
-          COMMENT_ID: ${{ github.event.comment.id }}
-          REPO: ${{ github.repository }}
-        run: python3 tools/ci/claim_command.py command
-  release:
-    if: github.event_name != 'issue_comment' && github.repository == 'horizon-rust/horizon'
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    permissions:
-      contents: read
-      issues: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: main
-          persist-credentials: false
-          sparse-checkout: |
-            tools/ci/nightly_set.py
-            tools/ci/claim_command.py
-          sparse-checkout-cone-mode: false
-      - name: Release stale claims
-        env:
-          GH_TOKEN: ${{ github.token }}
-          REPO: ${{ github.repository }}
-        run: python3 tools/ci/claim_command.py release

.github/workflows/game-build.yml

@@ -1,290 +0,0 @@
-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). 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,
-# which never runs what this one built. See docs/release-flow.md.
-on:
-  workflow_call:
-    inputs:
-      ref:
-        description: The commit to build
-        type: string
-        required: true
-      version:
-        description: The version built in (HORIZON_VERSION), e.g. 0.2.81 or nightly-2026-10-28
-        type: string
-        required: true
-      nightly:
-        description: A nightly's "<date> <short sha>" (HORIZON_NIGHTLY), shown by the game; empty for a release
-        type: string
-        default: ''
-      trusted:
-        # Only release.yml says true: it builds main. A nightly can hold pull requests nobody reviewed yet, whose
-        # build scripts and tests run here and could rewrite target/, the cargo home or a compiler cache. So an
-        # untrusted build never runs on the release runner, never saves the Rust cache (its key is its own anyway),
-        # and a trusted one never reads the machine's shared sccache, which pull requests' jobs write
-        # (tests/test_nightly.py pins all of it).
-        description: The source is main (a release); false for anything else (a nightly)
-        type: boolean
-        default: false
-      developer_id:
-        description: Sign the macOS programs with Developer ID and notarize the zip (the runner's keychain)
-        type: boolean
-        default: true
-permissions:
-  contents: read
-jobs:
-  exporters:
-    # This runner holds the maintainer's own pinned Minecraft jars. Only our classes leave it. An untrusted build
-    # goes to the Mac mini's nightly runner (macOS + horizon-nightly: ludovics-mac-mini-nightly, beside the one that
-    # runs pull requests' parity jobs, so a nightly never waits behind their queue), never the release runner
-    # (MAC_RUNNER: ludovics-mac-mini-release) nor parity-main's.
-    runs-on: ${{ inputs.trusted && vars.MAC_RUNNER || fromJSON('["self-hosted", "macOS", "horizon-nightly"]') }}
-    # Three full preparations (two isolated, one batched) besides the compile.
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ inputs.ref }}
-          persist-credentials: false
-          clean: true
-      - uses: dtolnay/rust-toolchain@stable
-      - run: bash tools/ci/runner-env.sh
-        env:
-          HORIZON_NO_SCCACHE: ${{ inputs.trusted && '1' || '' }}
-      - run: bash tools/ci/vanilla-data.sh
-      - name: Compile and validate original exporters against the pinned jars
-        shell: bash
-        run: |
-          set -euo pipefail
-          # target/ is gone after the clean checkout, and vanilla-data.sh builds the preparer only when it
-          # prepares afresh.
-          cargo build --release --locked -p horizon-prepare
-          # Compiled here, never taken from the runner's shared preparations: pull requests' parity jobs
-          # write those (vanilla-data.sh links .local/exporters to them).
-          rm -rf .local/exporters
-          bundle=$(target/release/horizon-prepare compile-exporters --root "$PWD" | tail -1)
-          mkdir -p exporters
-          cp -R "$bundle/server" "$bundle/client" "$bundle/manifest.json" exporters/
-          # Only our classes and their manifest leave this runner.
-          stray=$(find exporters -type f ! -path exporters/manifest.json \
-            ! \( -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
-        with:
-          name: original-exporters
-          path: exporters/
-          if-no-files-found: error
-          retention-days: 3
-
-  build:
-    needs: exporters
-    name: build ${{ matrix.name }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - name: linux
-            os: ubuntu-22.04
-            dir: horizon-linux-x86_64
-            asset: horizon-linux-x86_64.tar.gz
-            # 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: windows
-            os: windows-latest
-            dir: horizon-windows-x64
-            asset: horizon-windows-x64.zip
-            exe: .exe
-            # The C runtime linked in, so the game runs without the Visual C++ redistributable.
-            rustflags: -C target-feature=+crt-static
-          - name: macos
-            mac: true
-            dir: horizon-macos-arm64
-            asset: horizon-macos-arm64.zip
-    runs-on: ${{ matrix.mac && (inputs.trusted && vars.MAC_RUNNER || fromJSON('["self-hosted", "macOS", "horizon-nightly"]')) || matrix.os }}
-    # Notarizing the zip can take a few minutes.
-    timeout-minutes: ${{ matrix.mac && 60 || 40 }}
-    env:
-      RUSTFLAGS: ${{ matrix.rustflags }}
-      # The release's version, built in (horizon_core::release): --version, user agents, crash reports and
-      # telemetry say it. No version-bump commits.
-      HORIZON_VERSION: ${{ inputs.version }}
-      # A nightly's date and commit ("2026-10-28 0c02067"), which the game shows; empty for a release.
-      HORIZON_NIGHTLY: ${{ inputs.nightly }}
-    defaults:
-      run:
-        shell: bash
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ inputs.ref }}
-          persist-credentials: false
-          # Always from a clean checkout, the Mac mini's runner too: its work folder is shared with pull requests'
-          # parity jobs, and nothing they leave (target/, an untracked .cargo/config.toml, a build script's output)
-          # may end up in a release. target/ is rebuilt from scratch; .local/ is relinked by vanilla-data.sh, which
-          # keeps its preparations outside the checkout.
-          clean: true
-      - uses: dtolnay/rust-toolchain@stable
-      - uses: Swatinem/rust-cache@v2
-        if: runner.environment == 'github-hosted'
-        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'
-        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
-        run: cargo build --release --locked -p horizon-client --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
-        run: |
-          for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
-            test -f "target/release/$binary${{ matrix.exe }}" || { echo "::error::target/release/$binary${{ matrix.exe }} is missing"; exit 1; }
-          done
-      - name: The signing keychain, unlocked
-        if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' && inputs.developer_id
-        env:
-          MACOS_SIGN_IDENTITY: ${{ vars.MACOS_SIGN_IDENTITY }}
-        run: packaging/macos/keychain.sh unlock
-      - name: Signed with Developer ID and the hardened runtime
-        # Before the checks below, so they run the programs as players will.
-        if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' && inputs.developer_id
-        env:
-          MACOS_SIGN_IDENTITY: ${{ vars.MACOS_SIGN_IDENTITY }}
-        run: |
-          for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
-            codesign --force --options runtime --timestamp --keychain "$MACOS_SIGN_KEYCHAIN" \
-              --identifier "dev.horizon.${binary#horizon-}" --sign "$MACOS_SIGN_IDENTITY" "target/release/$binary"
-            codesign --verify --strict --verbose=2 "target/release/$binary"
-          done
-      - name: Only system libraries
-        # 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: |
-          for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
-            file="target/release/$binary${{ matrix.exe }}"
-            if [[ "$RUNNER_OS" == macOS ]]; then
-              others=$(otool -L "$file" | tail -n +2 | awk '{print $1}' | grep -v -E '^(/usr/lib/|/System/Library/)' || true)
-              [[ -z "$others" ]] || { echo "::error::$binary links $others"; exit 1; }
-            else
-              ${{ runner.os == 'Windows' && 'python' || 'python3' }} tools/check_imports.py "$file"
-            fi
-          done
-      - name: Every program starts
-        run: |
-          set -euo pipefail
-          bin=target/release
-          "$bin/horizon-client${{ matrix.exe }}" --help | grep -q -- '--resources'
-          "$bin/horizon-ctl${{ matrix.exe }}" --help > /dev/null
-          "$bin/horizon-prepare${{ matrix.exe }}" --help | grep -q -- '--minecraft-dir'
-          # The version is the release's.
-          for binary in horizon-prepare horizon-server; do
-            out=$("$bin/$binary${{ matrix.exe }}" --version | tr -d '\r')
-            echo "$out"
-            [[ "$out" == "$binary $HORIZON_VERSION" ]] || { echo "::error::expected $binary $HORIZON_VERSION"; exit 1; }
-          done
-      - name: Tools from the runner
-        if: runner.environment == 'self-hosted'
-        env:
-          HORIZON_NO_SCCACHE: ${{ inputs.trusted && '1' || '' }}
-        run: bash tools/ci/runner-env.sh
-      - name: Resources prepared from the runner's own Minecraft
-        if: runner.environment == 'self-hosted'
-        run: bash tools/ci/vanilla-data.sh
-      - name: The game runs (offscreen, a new world, 1500 frames)
-        if: runner.environment == 'self-hosted'
-        run: |
-          set -euo pipefail
-          # From a scratch folder: the game keeps its saves and options in the folder it starts in.
-          home="$RUNNER_TEMP/horizon-smoke"
-          rm -rf "$home" && mkdir -p "$home"
-          version=$(sed -n 's/.*"version": *"\([^"]*\)".*/\1/p' research-lock.json | head -1)
-          client="$PWD/target/release/horizon-client"
-          resources="$PWD/.local/horizon-client/$version"
-          (cd "$home" && HORIZON_HOME="$home" HORIZON_NO_AUDIO=1 "$client" --resources "$resources" --offscreen \
-            --world smoke --seed 1 --render-distance 4 --world-frames 1500 --timeout-seconds 180 \
-            --smoke-report "$home/smoke.json" > "$home/client.log" 2>&1) || { tail -40 "$home/client.log"; exit 1; }
-          python3 - "$home/smoke.json" <<'EOF'
-          import json, sys
-          report = json.load(open(sys.argv[1]))
-          print(json.dumps(report))
-          if report.get("error") is not None or report.get("frames", 0) < 1500 or not report.get("chunks") \
-                  or not report.get("meshed_sections") or not report.get("player"):
-              sys.exit("the smoke run did not draw a world")
-          EOF
-          # Published with the release; the publish job checks it again before it publishes anything.
-          cp "$home/smoke.json" "$RUNNER_TEMP/smoke-test.json"
-      - uses: actions/upload-artifact@v4
-        if: runner.environment == 'self-hosted'
-        with:
-          name: smoke-test.json
-          path: ${{ runner.temp }}/smoke-test.json
-          if-no-files-found: error
-          retention-days: 3
-      - uses: actions/download-artifact@v4
-        with:
-          name: original-exporters
-          path: exporters
-      - name: Package
-        run: |
-          set -euo pipefail
-          cargo run --locked -p xtask -- package "target/release/horizon-client${{ matrix.exe }}" "dist/${{ matrix.dir }}"
-          cd dist
-          rm -f "${{ matrix.asset }}"
-          case "${{ matrix.asset }}" in
-            *.tar.gz) tar czf "${{ matrix.asset }}" "${{ matrix.dir }}" ;;
-            *) if [[ "$RUNNER_OS" == Windows ]]; then 7z a -tzip "${{ matrix.asset }}" "${{ matrix.dir }}" > /dev/null
-               else
-                 # Without resource forks and extended attributes: plain ditto adds an
-                 # AppleDouble `._` file beside every file that has any.
-                 ditto -c -k --norsrc --noextattr --noqtn --keepParent "${{ matrix.dir }}" "${{ matrix.asset }}"
-                 if unzip -Z1 "${{ matrix.asset }}" | grep -E '(^|/)(\._|__MACOSX/)'; then
-                   echo "::error::macOS metadata files in ${{ matrix.asset }}"; exit 1
-                 fi
-               fi ;;
-          esac
-          ls -l "${{ matrix.asset }}"
-      - name: Notarized
-        # A zip of programs can't be stapled: Gatekeeper asks Apple the first time each one runs.
-        if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' && inputs.developer_id
-        run: |
-          for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
-            codesign --verify --strict "dist/${{ matrix.dir }}/$binary"
-          done
-          packaging/macos/notarize.sh "dist/${{ matrix.asset }}"
-      - uses: actions/upload-artifact@v4
-        with:
-          name: ${{ matrix.asset }}
-          path: dist/${{ matrix.asset }}
-          if-no-files-found: error
-          retention-days: 3
-      - name: The server build (the game without sound or controllers, as horizon-engine)
-        if: matrix.server_asset
-        run: |
-          set -euo pipefail
-          # After the client is packaged: target/release/horizon-client is rebuilt without the audio and
-          # controllers features, so it needs neither libasound nor libudev (minimal server images lack them).
-          cargo build --release --locked -p horizon-client --no-default-features --bin horizon-client
-          cargo run --locked -p xtask -- package-server target/release/horizon-client "dist/${{ matrix.server_dir }}"
-          folder="dist/${{ matrix.server_dir }}"
-          python3 tools/check_imports.py --server "$folder/horizon-engine" "$folder/horizon-server" "$folder/horizon-prepare"
-          "$folder/horizon-engine" --help | grep -q -- '--resources'
-          [[ "$("$folder/horizon-server" --version)" == "horizon-server $HORIZON_VERSION" ]]
-          cd dist
-          rm -f "${{ matrix.server_asset }}"
-          tar czf "${{ matrix.server_asset }}" "${{ matrix.server_dir }}"
-          ls -l "${{ matrix.server_asset }}"
-      - uses: actions/upload-artifact@v4
-        if: matrix.server_asset
-        with:
-          name: ${{ matrix.server_asset }}
-          path: dist/${{ matrix.server_asset }}
-          if-no-files-found: error
-          retention-days: 3
-      - name: The signing keychain, locked again
-        if: always() && runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' && inputs.developer_id
-        run: packaging/macos/keychain.sh lock
-

.github/workflows/launcher.yml

@@ -192,11 +192,9 @@ jobs:
           retry "$launcher" install latest
           "$launcher" versions --installed
           "$launcher" links --json
-          # `install latest` is the Nightly since #3342 (versions/nightly-<date>-<commit>), a vX.Y.Z before.
-          clients=("$HORIZON_LAUNCHER_HOME"/versions/*/horizon-client*)
+          clients=("$HORIZON_LAUNCHER_HOME"/versions/v*/horizon-client*)
           client="${clients[0]}"
           echo "installed client: $client"
-          [[ -f "$client" ]] || { echo "::error::no game installed under versions/"; exit 1; }
           # The game's Linux build is the game's to keep portable (release.yml checks it): a
           # 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; }

.github/workflows/nightly-build.yml

@@ -1,278 +0,0 @@
-name: nightly build
-run-name: nightly build${{ inputs.request && format(' (request {0})', inputs.request) || '' }}
-# The Nightly, the only build Horizon ships since 2026-10-28 (docs/release-flow.md "Nightly"; Ludovic). When the batch
-# train decides (release.yml, with the commit as `base`), once a night, and when a trusted
-# reviewer asks (`/nightly 2640 2642`, nightly-command.yml), it builds main plus the pull requests the reviewers
-# picked, merged in order (tools/ci/nightly_set.py), or main alone with none picked. Main is its newest commit where
-# checks and parity-main passed (or the `base` input), as for a release, and no Nightly is published while a
-# release-blocker is open. It publishes the result as the `nightly` pre-release, which every launcher and
-# `horizon-server update` install. The previous nightly stays a week as nightly-<date>.
-#
-# Why the signing key never meets the pull requests' code:
-# - `pick` merges the picked heads onto main with `git merge-tree --write-tree`: git objects only, no working tree,
-#   so none of their files reaches the disk and no hook, filter or script of theirs runs. It refuses any pull
-#   request that changes a path CODEOWNERS gives to Ludovic (this folder, tools/ci/, the signing and update code),
-#   pushes the merge as nightly/build-<date>-<n> and saves the set on the nightly-state branch.
-# - This file, game-build.yml and every script below run from main's copy: a schedule runs the default branch, and
-#   `uses: ./…` takes the caller's commit. A picked pull request's own .github/ is never read.
-# - `build` (game-build.yml, `trusted: false`) never reaches a release's tools: its macOS jobs run on the runner
-#   that already runs pull requests' parity jobs, never the release runner; its Rust cache has its own key and is
-#   never saved; and releases don't read the machine's shared sccache.
-# - `build` (game-build.yml) checks out and compiles the merge with no secrets: its token reads contents only and
-#   isn't kept in the checkout; the macOS programs are signed ad hoc (Developer ID needs the runner's keychain,
-#   which stays locked for nightlies).
-# - `sign` is the only job with RELEASE_SIGNING_KEY. It checks out nothing but main's tools/ci/sign_release.sh, which
-#   runs the runner's sha256sum and OpenSSL over the archives: it hashes them, never runs them. The signed message
-#   names the channel ("horizon release nightly"), so a nightly's signature can't pass for a release's.
-# - `publish` verifies the signature with main's horizon-release-sign, checks the smoke test, and only then moves
-#   the tag. Like sign, it never executes what build produced.
-# - The source ships with the build: `pick` writes horizon-source.tar.gz with `git archive` (git objects again, nothing
-#   run), `sign` signs it with the builds, and `publish` attaches it and tags the commit nightly-source/<date>-<short>
-#   for good (the dated release and the build branch go after 7 days; native mods pin the commit: docs/native-mods.md).
-#   gh workflow run "nightly build"                     # now (skips when the pick is the same commit as last night's)
-#   gh workflow run "nightly build" -f force=true       # build and publish even if unchanged
-#   gh workflow run "nightly build" -f dry_run=true     # build and sign with a throwaway key, publish nothing
-on:
-  schedule:
-    - cron: '17 20 * * *'  # 20:17 UTC: after the day's waves, before the 03:07 Paris parity audit takes the Mac mini
-  workflow_dispatch:
-    inputs:
-      force:
-        description: Build and publish even if tonight's pick is the commit already published
-        type: boolean
-        default: false
-      dry_run:
-        description: Build and sign with a throwaway key, publish nothing
-        type: boolean
-        default: false
-      issue:
-        description: The issue or pull request whose `/nightly` comment asked for this build (answered there)
-        type: string
-        default: ''
-      request:
-        description: The command's id, in the run's name so it can link the run
-        type: string
-        default: ''
-      prs:
-        description: A dry run's own set, `2640@<head> 2642@<head>` (the saved set stays)
-        type: string
-        default: ''
-      base:
-        description: The commit of main to build on (default main's newest with green checks and parity-main)
-        type: string
-        default: ''
-      urgent:
-        description: Past the day's cap of 12 builds (the train, for a release-now pull request or a forced run)
-        type: boolean
-        default: false
-permissions:
-  contents: read
-concurrency:
-  # One build at a time. A newer request replaces one still waiting: it builds the set as it is by then, so no pick
-  # is lost.
-  group: nightly-build
-  cancel-in-progress: false
-jobs:
-  pick:
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    permissions:
-      contents: write       # nightly/build-<date>-<n> and the nightly-state branch (main is protected)
-      issues: write         # says in the thread when the picked pull requests conflict
-      pull-requests: write
-      actions: read         # main's newest green checks and parity-main runs (the base)
-    outputs:
-      build: ${{ steps.pick.outputs.build }}
-      sha: ${{ steps.pick.outputs.sha }}
-      short: ${{ steps.pick.outputs.short }}
-      source: ${{ steps.pick.outputs.source }}
-      date: ${{ steps.pick.outputs.date }}
-      version: ${{ steps.pick.outputs.version }}
-      nightly: ${{ steps.pick.outputs.nightly }}
-      source_tag: ${{ steps.pick.outputs.source_tag }}
-      dry_run: ${{ steps.mode.outputs.dry_run }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          persist-credentials: false
-      - id: mode
-        # A dry run never publishes; a hand-started run off main is always one.
-        run: echo "dry_run=${{ github.event_name == 'workflow_dispatch' && (inputs.dry_run || github.ref != 'refs/heads/main') }}" >> "$GITHUB_OUTPUT"
-      - id: pick
-        env:
-          GH_TOKEN: ${{ github.token }}
-          FORCE: ${{ (inputs.force || steps.mode.outputs.dry_run == 'true') && 'yes' || '' }}
-          DRY_RUN: ${{ steps.mode.outputs.dry_run }}
-          NIGHTLY_ISSUE: ${{ inputs.issue }}
-          NIGHTLY_PRS: ${{ inputs.prs }}
-          NIGHTLY_BASE: ${{ inputs.base }}
-          NIGHTLY_URGENT: ${{ inputs.urgent }}
-        run: |
-          python3 tools/ci/nightly.py pick ${FORCE:+--force} | tee -a "$GITHUB_STEP_SUMMARY"
-          { echo; cat nightly-notes.md; } >> "$GITHUB_STEP_SUMMARY"
-      - name: Old nightly/build-* branches deleted (scheduled runs only)
-        # Ludovic, 2026-10-27: older than 7 days, but never the newest build or one a published nightly points to;
-        # nothing but nightly/build-* (nightly.py stale_builds, tests/test_nightly.py).
-        if: github.event_name == 'schedule'
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          { echo "### nightly/build-* branches"; python3 tools/ci/nightly.py prune-builds --days 7; } | tee -a "$GITHUB_STEP_SUMMARY"
-      - name: The source of the build (horizon-source.tar.gz)
-        if: steps.pick.outputs.build == 'true'
-        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
-        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
-        with:
-          name: nightly-notes
-          path: nightly-notes.md
-          retention-days: 3
-
-  build:
-    needs: pick
-    if: needs.pick.outputs.build == 'true'
-    uses: ./.github/workflows/game-build.yml
-    with:
-      ref: ${{ needs.pick.outputs.sha }}
-      version: ${{ needs.pick.outputs.version }}
-      nightly: ${{ needs.pick.outputs.nightly }}
-      developer_id: false
-      trusted: false  # it can hold unreviewed pull requests: their own cache key, never saved, not the release runner
-
-  sign:
-    needs: [pick, build]
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    # 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
-        with:
-          sparse-checkout: tools/ci/sign_release.sh
-          sparse-checkout-cone-mode: false
-          persist-credentials: false
-      - uses: actions/download-artifact@v4
-        with:
-          path: dist
-          pattern: horizon-*
-          merge-multiple: true
-      - name: Sign the checksums (SHA256SUMS, SHA256SUMS.sig) for the nightly channel
-        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' || '' }}
-        run: |
-          bash tools/ci/sign_release.sh nightly dist/horizon-linux-x86_64.tar.gz dist/horizon-windows-x64.zip \
-            dist/horizon-macos-arm64.zip dist/horizon-server-linux-x86_64.tar.gz dist/horizon-source.tar.gz
-      - uses: actions/upload-artifact@v4
-        with:
-          name: signature
-          path: dist/SHA256SUMS*
-          if-no-files-found: error
-          retention-days: 3
-      - uses: actions/upload-artifact@v4
-        if: needs.pick.outputs.dry_run == 'true'
-        with:
-          name: ephemeral.pub
-          path: dist/ephemeral.pub
-          retention-days: 3
-
-  publish:
-    needs: [pick, build, sign]
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    permissions:
-      contents: write
-      issues: read          # the open release-blocker issues (gate)
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-      - uses: actions/download-artifact@v4
-        with:
-          path: dist
-          merge-multiple: true
-      - name: The signature, checked as launchers check it
-        env:
-          EPHEMERAL: ${{ needs.pick.outputs.dry_run == 'true' && 'yes' || '' }}
-        run: |
-          key=(); [[ -n "$EPHEMERAL" ]] && key=(--key "$(cat dist/ephemeral.pub)")
-          cargo run --locked --quiet -p horizon-release-sign -- verify --tag nightly --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).
-        env:
-          GH_TOKEN: ${{ github.token }}
-          DRY_RUN: ${{ needs.pick.outputs.dry_run }}
-        run: |
-          if ! python3 tools/release_train.py gate --kind game --smoke dist/smoke-test.json --blockers; then
-            [[ "$DRY_RUN" == true ]] || { echo "::error::Nothing published"; exit 1; }
-            echo "::warning::A real run would publish nothing"
-          fi
-      - name: Publish as the `nightly` pre-release
-        if: needs.pick.outputs.dry_run != 'true'
-        env:
-          GH_TOKEN: ${{ github.token }}
-          SHA: ${{ needs.pick.outputs.sha }}
-          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)
-          # 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)" \
-            "dist/horizon-windows-x64.zip#Game files the launcher installs (Nightly): Windows (horizon-windows-x64.zip)" \
-            "dist/horizon-macos-arm64.zip#Game files the launcher installs (Nightly): macOS (horizon-macos-arm64.zip)" \
-            "dist/horizon-server-linux-x86_64.tar.gz#Nightly dedicated server for Linux (horizon-server-linux-x86_64.tar.gz)" \
-            "dist/horizon-source.tar.gz#Source of this Nightly, commit ${SHA:0:7} (horizon-source.tar.gz; kept for good as the tag $SOURCE_TAG)" \
-            dist/SHA256SUMS "${signature[@]}" dist/smoke-test.json
-          python3 tools/ci/nightly.py keep-source "$SHA" "$DATE"
-          python3 tools/ci/nightly.py prune --days 7
-      - name: Dry run, the nightly that would be published
-        if: needs.pick.outputs.dry_run == 'true'
-        run: |
-          echo "Would publish nightly at ${{ needs.pick.outputs.sha }} (${{ needs.pick.outputs.source }})"
-          ls -l dist
-
-  answer:
-    # Tells the thread that asked for this build how it ended. A conflict `pick` already explained there.
-    needs: [pick, build, sign, publish]
-    if: always() && inputs.issue != '' && needs.pick.result == 'success'
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    permissions:
-      issues: write
-      pull-requests: write
-    steps:
-      - env:
-          GH_TOKEN: ${{ github.token }}
-          ISSUE: ${{ inputs.issue }}
-          BUILD: ${{ needs.pick.outputs.build }}
-          PUBLISHED: ${{ needs.publish.result }}
-          DRY_RUN: ${{ needs.pick.outputs.dry_run }}
-          NAME: Nightly ${{ needs.pick.outputs.date }} · ${{ needs.pick.outputs.short }}
-          RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
-        run: |
-          if [[ "$BUILD" != true ]]; then
-            text="nothing new: the published Nightly is already this build."
-          elif [[ "$PUBLISHED" == success && "$DRY_RUN" == true ]]; then
-            text="the dry run built and signed $NAME; nothing was published. $RUN"
-          elif [[ "$PUBLISHED" == success ]]; then
-            text="published $NAME: https://github.com/$GITHUB_REPOSITORY/releases/tag/nightly. Launchers install it at their next check."
-          else
-            text="the build failed, nothing was published: $RUN"
-          fi
-          gh api "repos/$GITHUB_REPOSITORY/issues/$ISSUE/comments" -f body="🤖 Nightly: $text"

.github/workflows/nightly-command.yml

@@ -1,46 +0,0 @@
-name: nightly command
-# `/nightly …` comments: the trusted reviewers in .github/trusted-reviewers.txt (and Ludovic) pick the pull requests
-# the Nightly holds (docs/release-flow.md "Nightly channel", tools/ci/nightly_set.py). This job only checks who asked,
-# saves the set on the nightly-state branch, starts `nightly build` and answers in the thread.
-#
-# Why no pull request's code runs here, though the token can write:
-# - `issue_comment` always runs this file from main, whoever comments and wherever; a pull request's own copy of it
-#   is never read.
-# - It checks out main and runs main's nightly_set.py. The comment's text and author reach it as env vars, never in
-#   a shell line.
-# - It never checks out, fetches or merges a pull request: it reads their file lists through the API. The merge
-#   happens in nightly-build.yml's `pick`, with git objects only; their code runs in its `build`, without secrets.
-on:
-  issue_comment:
-    types: [created]
-permissions:
-  contents: read
-jobs:
-  command:
-    # Every other comment skips here, before a runner starts.
-    if: startsWith(github.event.comment.body, '/nightly') && github.event.comment.user.type != 'Bot'
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    permissions:
-      contents: write       # the nightly-state branch (main is protected)
-      actions: write        # starts `nightly build`
-      issues: write         # answers in the thread
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: main
-          persist-credentials: false
-          sparse-checkout: |
-            .github/CODEOWNERS
-            .github/trusted-reviewers.txt
-            tools/ci/nightly_set.py
-          sparse-checkout-cone-mode: false
-      - name: Run the command
-        env:
-          GH_TOKEN: ${{ github.token }}
-          BODY: ${{ github.event.comment.body }}
-          AUTHOR: ${{ github.event.comment.user.login }}
-          ISSUE: ${{ github.event.issue.number }}
-          COMMENT_URL: ${{ github.event.comment.html_url }}
-        run: python3 tools/ci/nightly_set.py command

.github/workflows/overlap-note.yml

@@ -1,41 +0,0 @@
-name: overlap note
-# One comment on a pull request naming the other open pull requests that close the same issue or change the same
-# functions, edited on every push (tools/ci/overlap_note.py, issue #3859).
-#
-# Why no pull request's code runs here, though `pull_request_target` gives a token that can write:
-# - `pull_request_target` runs this file and the script from main, never the pull request's copy.
-# - The checkout is main's (`ref: main`), blobless, with the script alone on disk. The pull requests' heads are fetched
-#   as git objects and only diffed, never checked out; git runs with hooks, fsmonitor, external diff and textconv off.
-# - The rest comes from the API. The token writes the comment only.
-on:
-  pull_request_target:
-    types: [opened, reopened, synchronize, ready_for_review]
-permissions:
-  contents: read
-jobs:
-  note:
-    if: github.event.pull_request.base.ref == 'main'
-    # A newer push replaces the note being computed.
-    concurrency:
-      group: overlap-note-${{ github.event.pull_request.number }}
-      cancel-in-progress: true
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    permissions:
-      contents: read
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: main
-          fetch-depth: 0
-          filter: blob:none
-          persist-credentials: false
-          sparse-checkout: |
-            tools/ci/overlap_note.py
-          sparse-checkout-cone-mode: false
-      - name: Note
-        env:
-          GH_TOKEN: ${{ github.token }}
-          REPO: ${{ github.repository }}
-        run: python3 tools/ci/overlap_note.py event

.github/workflows/pr-labels.yml

@@ -1,36 +0,0 @@
-name: pr labels
-# A pull request's kind label (the box ticked in the template) and area labels (the paths it changes):
-# tools/ci/pr_labels.py, CONTRIBUTING.md "Pull requests".
-#
-# Why no pull request's code runs here, though `pull_request_target` gives a token that can write to fork PRs:
-# - `pull_request_target` runs this file and the script from main, never the pull request's copy.
-# - It checks out main's script only (`ref: main`), never the pull request's head or merge commit.
-# - The script reads the event file (the description is data in JSON, never in a shell line) and the API's list of
-#   changed file names; it runs, builds and imports nothing of theirs. The token writes labels only.
-on:
-  pull_request_target:
-    types: [opened, reopened, synchronize, edited, ready_for_review]
-permissions:
-  contents: read
-jobs:
-  label:
-    # Title-only edits change nothing: skip them before a runner starts.
-    if: github.event.action != 'edited' || github.event.changes.body != null
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    permissions:
-      contents: read
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: main
-          persist-credentials: false
-          sparse-checkout: |
-            tools/ci/pr_labels.py
-          sparse-checkout-cone-mode: false
-      - name: Label
-        env:
-          GH_TOKEN: ${{ github.token }}
-          REPO: ${{ github.repository }}
-        run: python3 tools/ci/pr_labels.py event

.github/workflows/release.yml

@@ -1,15 +1,22 @@
 name: release
-# Automatic game releases (docs/release-flow.md). Horizon ships only the Nightly since 2026-10-28 (Ludovic): this
-# workflow is the batch train that decides when a new Nightly goes out, and `nightly build` (nightly-build.yml) builds,
-# signs and publishes it. After every green `checks` run on main, every 10 minutes (so a batch waiting for merges to
-# settle goes out without another merge) and by hand, tools/release_train.py decides, for a commit whose checks and
-# parity-main (the vanilla harnesses on main) both passed: a Nightly when 5 pull requests merged since the published
-# Nightly changed what players run and the newest merged 5 minutes ago, or when the oldest has waited 6 hours, or at
-# once for a pull request labelled release-now. RELEASES_PAUSED=1 (repository variable) stops it; so does an open issue
-# labelled release-blocker, forced runs too (nightly-build.yml checks again before publishing). One Nightly build at a
-# time, at most 12 a day (release-now and force=true pass the cap). No `vX.Y.Z` game release is made any more.
-#   gh workflow run release --ref <branch>                       # dry run: decides, starts nothing
-#   gh workflow run release -f dry_run=false -f force=true       # on main: a Nightly now, whatever the rules say
+# Automatic game releases (docs/release-flow.md). After every green `checks` run on main, every 10 minutes (so a
+# release waiting for merges to settle goes out without another merge) and by hand, tools/release_train.py decides,
+# for a commit whose checks and parity-main (the vanilla harnesses on main) both passed:
+# a release when 5 pull requests merged since the last one changed what players run and the newest merged 5 minutes
+# ago, or when the oldest has waited 6 hours, or at once for a pull request labelled release-now.
+# RELEASES_PAUSED=1 (repository variable) stops them; so does an open issue labelled release-blocker, forced runs too.
+# Builds Linux (an older Ubuntu, so the binary runs on any recent distribution and on NixOS through nix-ld) and
+# Windows on GitHub, macOS on the Mac mini's runner (MAC_RUNNER=macos-latest sends it to GitHub), then
+# publishes vX.Y.Z on the release line in .github/release-line.txt (docs/versioning.md; without it, the dated
+# vYYYY.MM.DD[.N] from before 0.2) with notes from the merged pull requests, as the release and GitHub's latest: one
+# channel, which launchers, `horizon-server update` and install.sh follow at once. So it is published only after the
+# checks that used to gate a promotion pass in this run: the Mac mini's smoke test drew a world, and no release-blocker
+# is open (tools/release_train.py gate); otherwise nothing is published. macOS: with the repository variable
+# MACOS_SIGN_IDENTITY set, the programs are signed with
+# Developer ID and the hardened runtime and the zip is notarized, from the runner's signing keychain
+# (packaging/macos/README.md); unset (forks), ad hoc.
+#   gh workflow run release --ref <branch>                       # dry run: builds and notes, publishes nothing
+#   gh workflow run release -f dry_run=false -f force=true       # on main: release now, whatever the rules say
 on:
   workflow_run:
     # A game release ships a commit both passed on (parity-main runs on batches: the newest commit it passed on).
@@ -21,24 +28,19 @@ on:
   workflow_dispatch:
     inputs:
       dry_run:
-        description: Decide only; start no Nightly build
+        description: Build everything and write the notes, but publish nothing
         type: boolean
         default: true
       force:
-        description: A Nightly even without player-facing changes, before merges settle, while paused or past the day's cap
+        description: Release even without player-facing changes, before merges settle or while paused
         type: boolean
         default: false
 permissions:
   contents: read
   # The open release-blocker issues (decide).
   issues: read
-  # The checks, parity-main and nightly build runs (decide).
-  actions: read
 concurrency:
-  # One release at a time. A hand-started dry run publishes nothing, so it can't race a real release: it gets a
-  # group of its own. In the shared group, a release queued behind it replaced it as the pending run and GitHub
-  # cancelled it (#2779's dry run, 2026-10-27), which happens all day while releases go out in batches.
-  group: game-release${{ github.event_name == 'workflow_dispatch' && inputs.dry_run && '-dry-run' || '' }}
+  group: game-release
   cancel-in-progress: false
 jobs:
   decide:
@@ -49,8 +51,9 @@ jobs:
     timeout-minutes: 10
     outputs:
       release: ${{ steps.decide.outputs.release }}
+      tag: ${{ steps.decide.outputs.tag }}
+      version: ${{ steps.decide.outputs.version }}
       head: ${{ steps.decide.outputs.head }}
-      urgent: ${{ steps.decide.outputs.urgent }}
       dry_run: ${{ steps.mode.outputs.dry_run }}
     steps:
       - uses: actions/checkout@v4
@@ -70,21 +73,364 @@ jobs:
         run: |
           python3 tools/release_train.py decide --kind game ${HEAD_SHA:+--head "$HEAD_SHA"} ${FORCE:+--force} | tee decision.json
           echo "### $(jq -r '.reason' decision.json)" >> "$GITHUB_STEP_SUMMARY"
+          # The version the programs are built with (docs/versioning.md): the tag without its v.
+          tag=$(jq -r '.tag' decision.json)
+          echo "version=${tag#v}" >> "$GITHUB_OUTPUT"
+          # A dry run builds whatever the decision, to test the builds.
+          if [[ "${{ steps.mode.outputs.dry_run }}" == true ]]; then echo "release=true" >> "$GITHUB_OUTPUT"; fi
 
-  nightly:
-    # The Nightly is the release: nightly-build.yml builds the decided commit plus the reviewers' picks, signs it for
-    # the Nightly channel and publishes it once its smoke test passed and no release-blocker is open.
+  exporters:
     needs: decide
-    if: needs.decide.outputs.release == 'true' && needs.decide.outputs.dry_run != 'true'
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    permissions:
-      actions: write  # starts `nightly build`
+    if: needs.decide.outputs.release == 'true'
+    # This runner holds the maintainer's own pinned Minecraft jars. Only our classes leave it.
+    runs-on: ${{ vars.MAC_RUNNER || 'ludovics-mac-mini' }}
+    # Three full preparations (two isolated, one batched) besides the compile.
+    timeout-minutes: 60
     steps:
-      - env:
-          GH_TOKEN: ${{ github.token }}
-          HEAD_SHA: ${{ needs.decide.outputs.head }}
-          URGENT: ${{ needs.decide.outputs.urgent }}
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.decide.outputs.head }}
+          persist-credentials: false
+          clean: true
+      - uses: dtolnay/rust-toolchain@stable
+      - run: bash tools/ci/runner-env.sh
+      - run: bash tools/ci/vanilla-data.sh
+      - name: Compile and validate original exporters against the pinned jars
+        shell: bash
         run: |
-          gh workflow run nightly-build.yml --repo "$GITHUB_REPOSITORY" --ref main -f base="$HEAD_SHA" -f urgent="$URGENT"
-          echo "### Started \`nightly build\` on ${HEAD_SHA:0:9}" >> "$GITHUB_STEP_SUMMARY"
+          set -euo pipefail
+          # target/ is gone after the clean checkout, and vanilla-data.sh builds the preparer only when it
+          # prepares afresh.
+          cargo build --release --locked -p horizon-prepare
+          # Compiled here, never taken from the runner's shared preparations: pull requests' parity jobs
+          # write those (vanilla-data.sh links .local/exporters to them).
+          rm -rf .local/exporters
+          bundle=$(target/release/horizon-prepare compile-exporters --root "$PWD" | tail -1)
+          mkdir -p exporters
+          cp -R "$bundle/server" "$bundle/client" "$bundle/manifest.json" exporters/
+          # Only our classes and their manifest leave this runner.
+          stray=$(find exporters -type f ! -path exporters/manifest.json \
+            ! \( -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
+        with:
+          name: original-exporters
+          path: exporters/
+          if-no-files-found: error
+          retention-days: 3
+
+  build:
+    needs: [decide, exporters]
+    if: needs.decide.outputs.release == 'true'
+    name: build ${{ matrix.name }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: linux
+            os: ubuntu-22.04
+            dir: horizon-linux-x86_64
+            asset: horizon-linux-x86_64.tar.gz
+            # 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: windows
+            os: windows-latest
+            dir: horizon-windows-x64
+            asset: horizon-windows-x64.zip
+            exe: .exe
+            # The C runtime linked in, so the game runs without the Visual C++ redistributable.
+            rustflags: -C target-feature=+crt-static
+          - name: macos
+            mac: true
+            dir: horizon-macos-arm64
+            asset: horizon-macos-arm64.zip
+    runs-on: ${{ matrix.mac && (vars.MAC_RUNNER || 'ludovics-mac-mini') || matrix.os }}
+    # Notarizing the zip can take a few minutes.
+    timeout-minutes: ${{ matrix.mac && 60 || 40 }}
+    env:
+      RUSTFLAGS: ${{ matrix.rustflags }}
+      # The release's version, built in (horizon_core::release): --version, user agents, crash reports and
+      # telemetry say it. No version-bump commits.
+      HORIZON_VERSION: ${{ needs.decide.outputs.version }}
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.decide.outputs.head }}
+          persist-credentials: false
+          # Always from a clean checkout, the Mac mini's runner too: its work folder is shared with pull requests'
+          # parity jobs, and nothing they leave (target/, an untracked .cargo/config.toml, a build script's output)
+          # may end up in a release. target/ is rebuilt from scratch; .local/ is relinked by vanilla-data.sh, which
+          # keeps its preparations outside the checkout.
+          clean: true
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        if: runner.environment == 'github-hosted'
+        with:
+          shared-key: release-${{ matrix.name }}
+      - name: ALSA and udev headers
+        if: runner.os == 'Linux'
+        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
+        # `horizon-client/mods`: every released game runs code mods (the feature is off in dev builds).
+        run: cargo build --release --locked --features horizon-client/mods -p horizon-client --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
+        run: |
+          for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
+            test -f "target/release/$binary${{ matrix.exe }}" || { echo "::error::target/release/$binary${{ matrix.exe }} is missing"; exit 1; }
+          done
+      - name: The signing keychain, unlocked
+        if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != ''
+        env:
+          MACOS_SIGN_IDENTITY: ${{ vars.MACOS_SIGN_IDENTITY }}
+        run: packaging/macos/keychain.sh unlock
+      - name: Signed with Developer ID and the hardened runtime
+        # Before the checks below, so they run the programs as players will.
+        if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != ''
+        env:
+          MACOS_SIGN_IDENTITY: ${{ vars.MACOS_SIGN_IDENTITY }}
+        run: |
+          for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
+            codesign --force --options runtime --timestamp --keychain "$MACOS_SIGN_KEYCHAIN" \
+              --identifier "dev.horizon.${binary#horizon-}" --sign "$MACOS_SIGN_IDENTITY" "target/release/$binary"
+            codesign --verify --strict --verbose=2 "target/release/$binary"
+          done
+      - name: Only system libraries
+        # 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: |
+          for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
+            file="target/release/$binary${{ matrix.exe }}"
+            if [[ "$RUNNER_OS" == macOS ]]; then
+              others=$(otool -L "$file" | tail -n +2 | awk '{print $1}' | grep -v -E '^(/usr/lib/|/System/Library/)' || true)
+              [[ -z "$others" ]] || { echo "::error::$binary links $others"; exit 1; }
+            else
+              ${{ runner.os == 'Windows' && 'python' || 'python3' }} tools/check_imports.py "$file"
+            fi
+          done
+      - name: Every program starts
+        run: |
+          set -euo pipefail
+          bin=target/release
+          "$bin/horizon-client${{ matrix.exe }}" --help | grep -q -- '--resources'
+          "$bin/horizon-ctl${{ matrix.exe }}" --help > /dev/null
+          "$bin/horizon-prepare${{ matrix.exe }}" --help | grep -q -- '--minecraft-dir'
+          # The version is the release's.
+          for binary in horizon-prepare horizon-server; do
+            out=$("$bin/$binary${{ matrix.exe }}" --version | tr -d '\r')
+            echo "$out"
+            [[ "$out" == "$binary $HORIZON_VERSION" ]] || { echo "::error::expected $binary $HORIZON_VERSION"; exit 1; }
+          done
+      - name: Tools from the runner
+        if: runner.environment == 'self-hosted'
+        run: bash tools/ci/runner-env.sh
+      - name: Resources prepared from the runner's own Minecraft
+        if: runner.environment == 'self-hosted'
+        run: bash tools/ci/vanilla-data.sh
+      - name: The game runs (offscreen, a new world, 1500 frames)
+        if: runner.environment == 'self-hosted'
+        run: |
+          set -euo pipefail
+          # From a scratch folder: the game keeps its saves and options in the folder it starts in.
+          home="$RUNNER_TEMP/horizon-smoke"
+          rm -rf "$home" && mkdir -p "$home"
+          version=$(sed -n 's/.*"version": *"\([^"]*\)".*/\1/p' research-lock.json | head -1)
+          client="$PWD/target/release/horizon-client"
+          resources="$PWD/.local/horizon-client/$version"
+          (cd "$home" && HORIZON_HOME="$home" HORIZON_NO_AUDIO=1 "$client" --resources "$resources" --offscreen \
+            --world smoke --seed 1 --render-distance 4 --world-frames 1500 --timeout-seconds 180 \
+            --smoke-report "$home/smoke.json" > "$home/client.log" 2>&1) || { tail -40 "$home/client.log"; exit 1; }
+          python3 - "$home/smoke.json" <<'EOF'
+          import json, sys
+          report = json.load(open(sys.argv[1]))
+          print(json.dumps(report))
+          if report.get("error") is not None or report.get("frames", 0) < 1500 or not report.get("chunks") \
+                  or not report.get("meshed_sections") or not report.get("player"):
+              sys.exit("the smoke run did not draw a world")
+          EOF
+          # Published with the release; the publish job checks it again before it publishes anything.
+          cp "$home/smoke.json" "$RUNNER_TEMP/smoke-test.json"
+      - uses: actions/upload-artifact@v4
+        if: runner.environment == 'self-hosted'
+        with:
+          name: smoke-test.json
+          path: ${{ runner.temp }}/smoke-test.json
+          if-no-files-found: error
+          retention-days: 3
+      - uses: actions/download-artifact@v4
+        with:
+          name: original-exporters
+          path: exporters
+      - name: Package
+        run: |
+          set -euo pipefail
+          cargo run --locked -p xtask -- package "target/release/horizon-client${{ matrix.exe }}" "dist/${{ matrix.dir }}"
+          cd dist
+          rm -f "${{ matrix.asset }}"
+          case "${{ matrix.asset }}" in
+            *.tar.gz) tar czf "${{ matrix.asset }}" "${{ matrix.dir }}" ;;
+            *) if [[ "$RUNNER_OS" == Windows ]]; then 7z a -tzip "${{ matrix.asset }}" "${{ matrix.dir }}" > /dev/null
+               else
+                 # Without resource forks and extended attributes: plain ditto adds an
+                 # AppleDouble `._` file beside every file that has any.
+                 ditto -c -k --norsrc --noextattr --noqtn --keepParent "${{ matrix.dir }}" "${{ matrix.asset }}"
+                 if unzip -Z1 "${{ matrix.asset }}" | grep -E '(^|/)(\._|__MACOSX/)'; then
+                   echo "::error::macOS metadata files in ${{ matrix.asset }}"; exit 1
+                 fi
+               fi ;;
+          esac
+          ls -l "${{ matrix.asset }}"
+      - name: Notarized
+        # A zip of programs can't be stapled: Gatekeeper asks Apple the first time each one runs.
+        if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != ''
+        run: |
+          for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
+            codesign --verify --strict "dist/${{ matrix.dir }}/$binary"
+          done
+          packaging/macos/notarize.sh "dist/${{ matrix.asset }}"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.asset }}
+          path: dist/${{ matrix.asset }}
+          if-no-files-found: error
+          retention-days: 3
+      - name: The server build (the game without sound or controllers, as horizon-engine)
+        if: matrix.server_asset
+        run: |
+          set -euo pipefail
+          # After the client is packaged: target/release/horizon-client is rebuilt without the audio and
+          # controllers features, so it needs neither libasound nor libudev (minimal server images lack them),
+          # and with code mods like the client.
+          cargo build --release --locked -p horizon-client --no-default-features --features mods --bin horizon-client
+          cargo run --locked -p xtask -- package-server target/release/horizon-client "dist/${{ matrix.server_dir }}"
+          folder="dist/${{ matrix.server_dir }}"
+          python3 tools/check_imports.py --server "$folder/horizon-engine" "$folder/horizon-server" "$folder/horizon-prepare"
+          "$folder/horizon-engine" --help | grep -q -- '--resources'
+          [[ "$("$folder/horizon-server" --version)" == "horizon-server $HORIZON_VERSION" ]]
+          cd dist
+          rm -f "${{ matrix.server_asset }}"
+          tar czf "${{ matrix.server_asset }}" "${{ matrix.server_dir }}"
+          ls -l "${{ matrix.server_asset }}"
+      - uses: actions/upload-artifact@v4
+        if: matrix.server_asset
+        with:
+          name: ${{ matrix.server_asset }}
+          path: dist/${{ matrix.server_asset }}
+          if-no-files-found: error
+          retention-days: 3
+      - name: The signing keychain, locked again
+        if: always() && runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != ''
+        run: packaging/macos/keychain.sh lock
+
+  sign:
+    needs: [decide, build]
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    # The only job that holds the release signing key, a secret of the `release` environment, which only main's real
+    # releases enter (dry runs sign with a throwaway key). It runs no code from the repository but
+    # 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
+        with:
+          sparse-checkout: tools/ci/sign_release.sh
+          sparse-checkout-cone-mode: false
+          persist-credentials: false
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist
+          pattern: horizon-*
+          merge-multiple: true
+      - name: Sign the checksums (SHA256SUMS, SHA256SUMS.sig)
+        env:
+          RELEASE_SIGNING_KEY: ${{ secrets.RELEASE_SIGNING_KEY }}
+          RELEASE_SIGNING_KEY_NEXT: ${{ secrets.RELEASE_SIGNING_KEY_NEXT }}
+          EPHEMERAL: ${{ needs.decide.outputs.dry_run == 'true' && 'yes' || '' }}
+          TAG: ${{ needs.decide.outputs.tag }}
+        run: |
+          bash tools/ci/sign_release.sh "$TAG" dist/horizon-linux-x86_64.tar.gz dist/horizon-windows-x64.zip \
+            dist/horizon-macos-arm64.zip dist/horizon-server-linux-x86_64.tar.gz
+      - uses: actions/upload-artifact@v4
+        with:
+          name: signature
+          path: dist/SHA256SUMS*
+          if-no-files-found: error
+          retention-days: 3
+      - uses: actions/upload-artifact@v4
+        if: needs.decide.outputs.dry_run == 'true'
+        with:
+          name: ephemeral.pub
+          path: dist/ephemeral.pub
+          retention-days: 3
+
+  publish:
+    needs: [decide, build, sign]
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    permissions:
+      contents: write
+      issues: read
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Notes
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          python3 tools/release_train.py notes --kind game --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
+        with:
+          path: dist
+          merge-multiple: true
+      - name: The signature, checked as launchers check it
+        env:
+          TAG: ${{ needs.decide.outputs.tag }}
+          EPHEMERAL: ${{ needs.decide.outputs.dry_run == 'true' && 'yes' || '' }}
+        run: |
+          key=(); [[ -n "$EPHEMERAL" ]] && key=(--key "$(cat dist/ephemeral.pub)")
+          cargo run --locked --quiet -p horizon-release-sign -- verify --tag "$TAG" --publishing "${key[@]}" dist
+      - name: Ready to publish (the smoke test passed, no release-blocker is open)
+        # Right before publishing: an issue labelled while the builds ran still holds this release. A dry run only
+        # reports what a real run would do.
+        env:
+          GH_TOKEN: ${{ github.token }}
+          DRY_RUN: ${{ needs.decide.outputs.dry_run }}
+        run: |
+          if ! python3 tools/release_train.py gate --kind game --smoke dist/smoke-test.json --blockers; then
+            [[ "$DRY_RUN" == true ]] || { echo "::error::Nothing published"; exit 1; }
+            echo "::warning::A real run would publish nothing"
+          fi
+      - name: Publish ${{ needs.decide.outputs.tag }}
+        if: needs.decide.outputs.dry_run != 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG: ${{ needs.decide.outputs.tag }}
+        run: |
+          signature=(); [[ -f dist/SHA256SUMS.sig ]] && signature=(dist/SHA256SUMS.sig)
+          # The release and the latest at once: there is one channel (docs/release-flow.md). Each archive gets a
+          # label (file#label), which GitHub's page shows instead of the file name, so nobody takes the game's
+          # files for the download (#1647). Launchers, servers and install.sh match the name, which stays.
+          gh release create "$TAG" --target "${{ needs.decide.outputs.head }}" --title "$(cat notes/title.txt)" \
+            --notes-file notes/body.md --latest \
+            "dist/horizon-linux-x86_64.tar.gz#Game files the launcher installs: Linux (horizon-linux-x86_64.tar.gz)" \
+            "dist/horizon-windows-x64.zip#Game files the launcher installs: Windows (horizon-windows-x64.zip)" \
+            "dist/horizon-macos-arm64.zip#Game files the launcher installs: macOS (horizon-macos-arm64.zip)" \
+            "dist/horizon-server-linux-x86_64.tar.gz#Dedicated server for Linux (horizon-server-linux-x86_64.tar.gz)" \
+            dist/SHA256SUMS "${signature[@]}" dist/smoke-test.json
+      - name: Dry run, the release that would be published
+        if: needs.decide.outputs.dry_run == 'true'
+        run: |
+          echo "Would publish ${{ needs.decide.outputs.tag }} at ${{ needs.decide.outputs.head }} as the release and latest: $(cat notes/title.txt)"
+          ls -l dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: release-notes
+          path: notes/
+          retention-days: 3

.github/workflows/run-parity.yml

@@ -5,15 +5,11 @@ name: run-parity
 # skipped `verify`, and GitHub counts a skipped required check as passed.
 on:
   pull_request:
-    # A push starts a run only to cancel the old head's (see concurrency): the job runs on the label alone.
-    types: [labeled, synchronize]
+    types: [labeled]
 permissions:
   contents: read
 concurrency:
-  # The run-parity label and pushes share one group per pull request, so the newest run cancels the one before: a
-  # pushed pull request's run tested a head the merge would no longer land. Any other label gets a group of its own:
-  # in the shared one, adding needs-proof cancelled the parity run queued seconds before (run 40766180150).
-  group: run-parity-${{ github.event.pull_request.number }}${{ github.event.action == 'labeled' && github.event.label.name != 'run-parity' && format('-{0}', github.run_id) || '' }}
+  group: run-parity-${{ github.event.pull_request.number }}
   cancel-in-progress: true
 env:
   # Test runs never reach the telemetry server: no live-count ping, no uploads (docs/telemetry.md).

.github/workflows/triage-command.yml

@@ -1,48 +0,0 @@
-name: triage command
-# `/close`, `/reopen`, `/label`, `/unlabel` comments: the trusted reviewers in .github/trusted-reviewers.txt (and
-# Ludovic) triage issues and pull requests without any repository role (docs/release-flow.md "Trusted reviewers",
-# tools/ci/triage_command.py).
-#
-# Why no pull request's code runs here, though the token can write:
-# - `issue_comment` always runs this file from main, whoever comments and wherever.
-# - It checks out main's script and list only, never a pull request; it reads threads through the API.
-# - The comment's text and author reach the script as env vars, never in a shell line. The token stays in the step.
-on:
-  issue_comment:
-    types: [created]
-permissions:
-  contents: read
-jobs:
-  command:
-    # Every other comment skips here, before a runner starts.
-    if: >-
-      github.event.comment.user.type != 'Bot' && (
-      startsWith(github.event.comment.body, '/close') ||
-      startsWith(github.event.comment.body, '/reopen') ||
-      startsWith(github.event.comment.body, '/label') ||
-      startsWith(github.event.comment.body, '/unlabel'))
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    permissions:
-      contents: read
-      issues: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: main
-          persist-credentials: false
-          sparse-checkout: |
-            .github/trusted-reviewers.txt
-            tools/ci/nightly_set.py
-            tools/ci/triage_command.py
-          sparse-checkout-cone-mode: false
-      - name: Run the command
-        env:
-          GH_TOKEN: ${{ github.token }}
-          BODY: ${{ github.event.comment.body }}
-          AUTHOR: ${{ github.event.comment.user.login }}
-          ISSUE: ${{ github.event.issue.number }}
-          REPO: ${{ github.repository }}
-          COMMENT_URL: ${{ github.event.comment.html_url }}
-        run: python3 tools/ci/triage_command.py command

AGENTS.md

@@ -13,15 +13,13 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
   `XDG_CONFIG_HOME`, plus `HORIZON_LAUNCHER_NO_SELF_UPDATE=1` and `HORIZON_NO_AUDIO=1`, and, for the
   launcher, `HORIZON_LAUNCHER_TRASH`, `HORIZON_LAUNCHER_CLIPBOARD` and `HORIZON_LAUNCHER_DESKTOP` pointing into the scratch home. Never write to
   `~/.local/share/{applications,horizon,horizon-launcher}` or `~/.local/bin`.
-- **Mark what an agent posts.** A PR body starts with a line naming the person whose agent opened it and
-  the tool: `> 🤖 Opened by <login>'s AI agent (<tool, model>), not by <login> personally.`, where `<login>`
-  is the GitHub account the PR is opened from (`gh api user --jq .login`). Issues say "Filed by", reviews
-  "Review by". Every comment starts with `🤖 Agent:`. Write only as the person you work for: the lines on
-  this page that name Ludovic are for his own agents (account `ludovic111`), never for anyone else's.
+- **Mark what an agent posts.** A PR body starts with a line naming whose agent opened it and with what.
+  Ludovic's agents write `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.`, and a
+  contributor's agent names its own person and tool (issues: "Filed by", reviews: "Review by"). Every
+  comment starts with `🤖 Agent:`. Never write as Ludovic or as anyone else.
 - **Attribution.** Commits end with a `Co-Authored-By:` line for the agent that wrote them, and PR bodies
-  with that agent's own "Generated with" line. Example, Ludovic's agents (Claude Code on `ludovic111`):
-  first line `> 🤖 Opened by Ludovic's AI agent (Claude), not by Ludovic himself.`, commits
-  `Co-Authored-By: Claude <model> <[email protected]>`, last line
+  with that agent's own "Generated with" line. Ludovic's agents use
+  `Co-Authored-By: Claude <model> <[email protected]>` and
   `🤖 Generated with [Claude Code](https://claude.com/claude-code)`.
 - Everything players run is Rust. Python/Java only for dev tools and harness drivers in `tools/`.
 - Horizon-only features follow [docs/design-system.md](docs/design-system.md) and are off by default where
@@ -30,8 +28,6 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
   change), none for a fix. Agents never add `release-now`: the maintainer decides it. Merges ship in batches of 5, or after
   6 hours ([docs/release-flow.md](docs/release-flow.md)).
 - Contributors first: `gh pr list --state open --search <area>` before you start; never duplicate theirs.
-- **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.
 
 ## Crates
 
@@ -39,12 +35,9 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 
 | Crate | Owns |
 |---|---|
-| `horizon-client` | The game: a lib (`src/lib.rs`, ~100 flat modules: gameplay, networking, title screens) and the bin (`src/main.rs` → `game.rs` + `game/`), plus `horizon-ctl` (`src/bin/horizon-ctl/`). Also the dedicated server (`--dedicated`) |
-| `horizon-items` | Blocks and items below gameplay: `blocks.rs` (block facts), `items.rs`, `item_data.rs` (components), `enchant.rs`, `cooldowns.rs`, `bundle.rs`, `item_nbt.rs`. Re-exported as `horizon_client::items`... |
+| `horizon-client` | The game: a lib (`src/lib.rs`, ~180 flat modules) and the bin (`src/main.rs` → `game.rs` + `game/`), plus `horizon-ctl` (`src/bin/horizon-ctl/`). Also the dedicated server (`--dedicated`) |
 | `horizon-command` | Command parsing (Brigadier): the vanilla tree, argument types, selectors, suggestions, the tree's network form. Re-exported as `horizon_client::command` |
 | `horizon-client-core` | The client lib's bottom layer: `text.rs`, `lang.rs`, `snbt.rs`, `nbt_path.rs`, `component.rs`, `scoreboard.rs`, `bossbar.rs`, `gamerules.rs`, `block_entity_nbt.rs`, registry/particle/sound tables. Re-exported under the old paths (`horizon_client::text`...) |
-| `horizon-client-input` | Key bindings and key names, toggle keys, mouse options, controller settings and glyphs, the clipboard, window options (`keybinds.rs`, `gamepad.rs`, `mouse.rs`, `window.rs`...). Re-exported under the old paths |
-| `horizon-client-render` | The client's world data, rendering and screens (chunks, meshing, light, streaming, `gfx`, HUD, menus, settings): ~80 modules that horizon-client re-exports under the same paths. Nothing in it reaches gameplay |
 | `horizon-world` | Vanilla world data with no gameplay loop: NBT, regions, chunks, `datafix/`, `worldgen/`, `level/` (server-side block behaviour, ticks, redstone), entity physics, items, effects, food, damage |
 | `horizon-core` | Simulation primitives: Java `Random`s, `jmath` (HotSpot-exact `Math`), positions, noise, density, paletted storage, `version.rs` (the pinned version) |
 | `horizon-protocol` | Network protocol 777: codecs, framing, encryption, `packets/{handshake,status,login,configuration,play}.rs`, `entity_data.rs` |
@@ -53,7 +46,7 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 | `horizon-server` | `horizon-server`: `server.toml`, CLI, supervisor of the headless game ([docs/hosting.md](docs/hosting.md)) |
 | `horizon-server-files` | `server.properties`, eula, ops/whitelist/bans, usercache |
 | `horizon-friends`, `horizon-relay` | Play with Friends: invite codes, encrypted tunnel, the relay ([docs/play-with-friends.md](docs/play-with-friends.md)) |
-| `horizon-mods`, `cargo-horizon-mod` | Content mods (`.hmod`: manifest, content fence, no code), the registry index and `.hpack`, and `cargo horizon-mod` (`new`, `build`, `run`, `check`, `registry`) ([docs/mods.md](docs/mods.md)). Code mods are native, built by the launcher ([docs/native-mods.md](docs/native-mods.md)) |
+| `horizon-mods`, `horizon-mod-sdk`, `cargo-horizon-mod` | Sandboxed WebAssembly mods: runtime, SDK + WIT, `cargo horizon-mod` ([docs/mods.md](docs/mods.md)) |
 | `horizon-port-pack` | Porting Java modpacks ([docs/modpacks.md](docs/modpacks.md)) |
 | `horizon-shader-api` | Horizon's own WGSL shader packs ([docs/api/shaders.md](docs/api/shaders.md)): `horizon-shaders.toml`, the `.hshader` package; shared by the game, the launcher and the registry |
 | `horizon-shaders` | Shader packs (the `shaders/` folder format), rebuilt clean-room from a written spec of the format; no wgpu |
@@ -64,7 +57,7 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 
 Other top-level folders: `tools/` (harnesses and dev scripts), `tests/` (Python unit tests: `python3 -m
 unittest discover -s tests`), `mods/horizon/src/test/java/dev/horizonlab/parity/` (Java oracles),
-`docs/`, `.github/workflows/`. The website (playhorizon.dev) is the private horizon-rust/horizon-site: its build
+`docs/`, `.github/workflows/`. The website (playhorizon.dev) is the private ludovic111/horizon-site: its build
 reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` and `crates/horizon-theme/tokens.css` from main.
 
 ## Build and test fast
@@ -73,12 +66,12 @@ reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` an
 python3 tools/pr_ready.py                  # the self-check: fmt, clippy -D warnings, touched crates' tests, harnesses; paste its block in the PR
 python3 tools/pr_ready.py --quick          # same without harnesses
 cargo test -p horizon-client --lib --bins --tests   # skips the 104 examples (pr_ready does this); `--doc` separately
-cargo test -p horizon-client --lib mod_content::tests:: -- --ignored   # the 5 slow content-root tests, #[ignore]d; pr_ready runs them when mod content, assets, blocks or items change
+cargo test -p horizon-client --features horizon-client/mods --lib mod_content::tests:: -- --ignored   # the 5 slow content-root tests, #[ignore]d; pr_ready runs them when mod content, assets, blocks or items change
 cargo build --profile fast -p horizon-client        # optimized, quick to link: use it to play or run lan_e2e
 python3 tools/parity.py --changed origin/main       # the harnesses your branch can affect (CI's parity job)
 python3 tools/parity.py --changed-files paths.txt --list   # which harnesses cover these files, without running them
 python3 tools/parity.py mob_ai sculk       # named harnesses
-python3 tools/lan_e2e.py --check chest     # two real games over LAN (server-thread host)
+python3 tools/lan_e2e.py --check chest     # two real games over LAN (server-thread host); --in-frame compares the fallback
 python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 ```
 
@@ -93,6 +86,9 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 - What a change reruns (of 329 harnesses, measured 2026-10-23): a file of the game binary (`game.rs`, `game/`)
   ~25, a file of the client lib ~103, of `horizon-world` ~103–109, of `horizon-core` ~119. Plan for it.
 - Rust integration tests: `crates/horizon-client/tests/` (`lan_bot.rs`, `generation_saves.rs`, `streaming_meshes.rs`).
+- **macOS:** `cargo build/test --workspace` may fail to link the two wasm guest cdylibs (undefined
+  `horizon:mods/events` symbols) until #1446 lands: add `--exclude coords-hud --exclude predator-missile --exclude horizon-mods-test-guest --exclude horizon-mods-test-ui-guest`.
+  Their real check is `cargo test -p horizon-mods` (builds them for `wasm32-unknown-unknown`).
 - Linux needs `libasound2-dev libudev-dev`; `--no-default-features` drops audio and controllers (the server build).
 - Run and drive the game (starts the `horizon-client` beside `horizon-ctl`; other arguments go to the game):
   `target/fast/horizon-ctl --socket $PWD/ctl.sock launch --world W --creative --offscreen --wait --resources $PWD/.local/horizon-client/26.3`,
@@ -101,9 +97,6 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 
 ## Vanilla reference
 
-- Start parity work from the port ledger, not grep: `python3 tools/port_ledger.py issue N` (or `where
-  Class.method`, `what file:line`), and `check --base origin/main` before the PR. How:
-  [.claude/skills/vanilla-parity/SKILL.md](.claude/skills/vanilla-parity/SKILL.md), [docs/port-ledger.md](docs/port-ledger.md).
 - Decompiled sources: `.local/minecraft/26.3/sources/{client,server}/` (`python3 tools/lab.py decompile`).
 - Bytecode queries (callers through lambdas, every overload):
   `python3 tools/rea_vanilla.py method net.minecraft.world.level.block.DispenserBlock dispenseFrom`
@@ -115,20 +108,19 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 
 ## horizon-client: where things live
 
-`L:` = lib (`crates/horizon-client/src/`, or `crates/horizon-client-render/src/` for the modules that crate holds, under
-the same `horizon_client::<module>` paths), `G:` = bin (`crates/horizon-client/src/game/`). The lib can't see
+`L:` = lib (`crates/horizon-client/src/`), `G:` = bin (`crates/horizon-client/src/game/`). The lib can't see
 `Game`; bin code reaches the lib as `horizon_client::<module>`.
 
 | Subsystem | Files |
 |---|---|
-| Game loop, tick, frame | `game.rs`: `fn run`, `impl ApplicationHandler for Game` (`window_event`, `about_to_wait`), `fn tick`, `fn tick_world`, `fn render`; L: `clock.rs`, `spans.rs`; `horizon-client-input/src/window.rs` |
+| Game loop, tick, frame | `game.rs`: `fn run`, `impl ApplicationHandler for Game` (`window_event`, `about_to_wait`), `fn tick`, `fn tick_world`, `fn render`; L: `clock.rs`, `window.rs`, `spans.rs` |
 | Rendering | L: `gfx.rs` (`Renderer::new`, `Renderer::render`), `gfx/` (cull, occlusion, translucency, upload, timing, lod, weather, stars, end_sky), `*.wgsl`, `particles.rs`, `block_entity_render.rs`, `item_render.rs`, `fog.rs`, `clouds.rs`, `camera.rs`, `first_person.rs`; G: `render_tick.rs`, `item_draw.rs` |
 | Chunks, streaming, light | L: `streaming.rs` (worker pool: generate, light, mesh), `world.rs`, `chunk.rs`, `chunk_map.rs`, `light.rs`, `mesher.rs` + `mesher/`, `vanillagen.rs` (binds horizon-world's generator), `lod.rs` + `lod/`, `ticket_levels.rs`; G: `world_loading.rs`, `postprocess.rs`; game.rs `fn update_world` |
 | World generation | `crates/horizon-world/src/worldgen/` (`generator*.rs`, `feature_graph.rs`, `structure/`, `carver/`) |
 | Block behaviour | `crates/horizon-world/src/level/` (`mod.rs`, `tick.rs`, `hooks.rs`, `redstone.rs`, `place.rs`, `interact.rs`); game.rs `fn tick_blocks`, `fn process_level_events` |
 | Mobs | L: `mobs.rs` (types), `mobs/` (`ai.rs`, `goals.rs`, `brain.rs`, `*_brain.rs`, `nav.rs`, `path.rs`, `species.rs`, `spawning.rs`, `render.rs`, `anim.rs`); G: `creatures.rs` (ticking, spawning, mob events), one file per mob family (`dragon.rs`, `wither.rs`, `villagers.rs`, `piglins.rs`, `golems.rs`...), `natural_spawning.rs` |
 | Other entities | L: `entities.rs`, `projectiles.rs`, `arrows.rs`; G: `boats.rs`, `minecarts.rs`, `mounts.rs`, `armor_stands.rs`, `paintings.rs`, `frames.rs`, `fireworks.rs`, `tnt.rs`, `explosion.rs` |
-| Player actions | game.rs (`fn use_hand`, `fn use_item`, `fn attack`, `fn tick_mining`, `fn break_block`); G: `hand.rs`, `combat.rs`, `consume.rs`, `potions.rs`, `shield.rs`, `crossbow.rs`, `trident.rs`, `fishing.rs`; L: `motion.rs` + `motion/` (movement), `collisions.rs`; crate `horizon-items`: `items.rs`, `item_data.rs`, `enchant.rs`, `blocks.rs` |
+| Player actions | game.rs (`fn use_hand`, `fn use_item`, `fn attack`, `fn tick_mining`, `fn break_block`); G: `hand.rs`, `combat.rs`, `consume.rs`, `potions.rs`, `shield.rs`, `crossbow.rs`, `trident.rs`, `fishing.rs`; L: `motion.rs` + `motion/` (movement), `collisions.rs`, `items.rs`, `item_data.rs` |
 | Inventory and containers | L: `menu.rs` (`AbstractContainerMenu.clicked`), `container_screen.rs`, `containers.rs`, `creative.rs`, `crafting.rs`, `recipe_book*.rs`, `stations.rs`, `merchant.rs`; game.rs `fn menu_ops`, `fn click_inventory`; G: `stations.rs`, `trading.rs`, `recipe_book.rs`, `machines.rs` |
 | Commands | parse: crate `horizon-command` (`args.rs`, `selector.rs`, `tree_*.rs`, `vanilla.rs`); run: G: `commands.rs` (dispatch) + `commands/*.rs` (`admin`, `execute`, `items`, `players`, `world_cmds`...); L: `scoreboard_cmd.rs`, `data_cmd.rs`; `horizon-client-core`: `nbt_path.rs`, `scoreboard.rs`; G: `functions.rs`, `command_blocks.rs` |
 | UI screens | `Screen` enum in game.rs; L: `title.rs` + `title/`, `options_ui.rs`, `multiplayer.rs`, `pack_screen.rs`, `graphics_ui.rs`, `screen_draw.rs`, `ui.rs` (widgets), `hud.rs`, `hud_layout.rs`, `hud_overlays.rs`, `chat.rs`, `tab_list.rs`; G: `startup_menu.rs`, `screens.rs` (pause, death), `options.rs`, `lan_screen.rs`, `chat.rs`, `sign_edit.rs`, `books.rs` |
@@ -137,7 +129,7 @@ the same `horizon_client::<module>` paths), `G:` = bin (`crates/horizon-client/s
 | Integrated server | G: `integrated.rs` (the server thread), `levels.rs` (one level per dimension, `fn tick_server`), `server_travel.rs` |
 | Dedicated server | G: `dedicated.rs`, `dedicated/status.rs`; crates `horizon-server-files`, `horizon-server` |
 | Save and load | L: `save.rs` (level.dat, regions, playerdata), `entity_nbt.rs`, `options_file.rs`; `horizon-client-core/src/block_entity_nbt.rs`; G: `saving.rs`, `persist.rs` (entities); `crates/horizon-world/src/{region.rs,nbt.rs,datafix/}` |
-| Input | game.rs `fn window_event`, `fn key_pressed`, `fn play_mouse`; crate `horizon-client-input` (`keybinds.rs`, `keymapping.rs`, `key_names.rs`, `mouse.rs`, `input.rs`, `interaction_input.rs`, `gamepad.rs`, `clipboard.rs`); L: `osk.rs`; G: `pad.rs`, `pad_menu.rs` |
+| Input | game.rs `fn window_event`, `fn key_pressed`, `fn play_mouse`; L: `keybinds.rs`, `keymapping.rs`, `key_names.rs`, `mouse.rs`, `input.rs`, `interaction_input.rs`, `gamepad.rs`, `osk.rs`, `clipboard.rs`; G: `pad.rs`, `pad_menu.rs` |
 | Audio | L: `audio.rs` (mixer), `sound_engine.rs`, `sound_events.rs`, `music.rs`, `ambience.rs`; G: `music.rs`, `subtitle_hud.rs` |
 | Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`; `horizon-client-core/src/lang.rs`; crate `horizon-assets`; G: `packs.rs` |
 | Agent control | L: `control.rs` (socket), `bin/horizon-ctl/`; G: `control.rs`, `agent.rs`, `events.rs`, `ui_control.rs` ([docs/agent-control.md](docs/agent-control.md)) |
@@ -168,18 +160,17 @@ the same `horizon_client::<module>` paths), `G:` = bin (`crates/horizon-client/s
    "Server thread" with one level per dimension; the window joins it as a client through memory (`remote`),
    exactly as a LAN guest or a dedicated server's player does. This is what players run. Open
    `[server-thread]` issues list the gaps left.
-2. **In-frame (`--in-frame`, `--no-server-thread` or `HORIZON_SERVER_THREAD=0`): DEPRECATED, never use it, it
-   will be removed soon.** The window's `Game` ticks the world itself, one level that follows the player
-   (`fn enter_dimension`). Compatibility does not matter: don't add features or fixes for it, don't write new
-   tests against it, and move code off it when you touch it. The deterministic rule fixtures still run on it
-   until they are ported.
+2. **In-frame (`--in-frame`, `--no-server-thread` or `HORIZON_SERVER_THREAD=0`):** the window's `Game` ticks
+   the world itself, one level that follows the player (`fn enter_dimension`). Deterministic rule fixtures still use this path; player-facing integration uses the default server thread.
 
-LAN guests and dedicated servers always use the server code, so a fix there serves both. Test the server
-thread when you touch player-facing gameplay:
+LAN guests and dedicated servers always use the server code, so a fix there serves both. Test both paths
+when you touch player-facing gameplay:
 
 ```sh
 cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T               # server thread
+cargo run --profile fast -p horizon-client -- --resources .local/horizon-client/26.3 --world T --in-frame    # in-frame
 python3 tools/lan_e2e.py --check <name>                  # host on its server thread, guest is a server client
+python3 tools/lan_e2e.py --in-frame --check <name>       # comparison (portals, levels, distance, lava need server-thread mode)
 python3 tools/parity.py dedicated_server server_entities server_player_damage
 ```
 

CONTRIBUTING.md

@@ -74,19 +74,6 @@ including examples. The dependency scope includes optional, platform, build and
 Tests run library, binary, integration and doc tests without building unrelated example executables. Shared Cargo
 configuration and toolchain changes select the whole workspace; CI also keeps its workspace-wide checks.
 
-## Claim before you start
-
-Work is tracked in GitHub issues, and an issue that is assigned is taken (so is one with the `in progress` label:
-claimed on Discord with Kira's `/claim`): pick another, or ask its holder in the thread. Before you start, comment
-**`/claim`** on the issue; you are assigned at once, no role needed. No issue for your work yet? Open one (a line is
-enough), then claim it. `/unclaim` gives it back.
-
-A claim with no open pull request linking the issue (`Fixes #123` in the description, or a draft) is released after
-5 days, with a comment: open a draft early. You can hold 5 open issues at a time. Agents claim the same way.
-
-When your pull request changes the same functions as another open one, or closes the same issue, a bot comment names
-it (edited on every push, never repeated): talk to its author in the thread before you both finish the same work.
-
 ## Pull requests
 
 - **Small.** One change per pull request, under about 500 lines of code where you can; split bigger work into
@@ -95,17 +82,10 @@ it (edited on every push, never repeated): talk to its author in the thread befo
   can see.
 - **Tick "Allow edits by maintainers".** When something small is left (a lint, a rebase, a nit) we push the fixup
   ourselves instead of sending it back to you; only design questions come back.
-- **Tick its kind** in the template: `parity` (Horizon now does what vanilla does), `bug` (a crash or breakage),
-  `perf`, `feature` (new for players), `extra` (Horizon-only, off by default), `tooling` or `docs`. A workflow sets
-  that label, and area labels (`launcher`, `mobs`, `worldgen`, `rendering`...) from the paths you change.
-  `label:parity` is the list of real progress toward vanilla.
-- **Release labels** (we set them if you can't): `feature` also puts it under "New" in the release notes,
-  `skip-release` when players see no change (tooling, docs, tests), nothing for a fix.
+- **Labels** (we set them if you can't): `feature` when players get something new (it appears under "New" in the
+  release notes), `skip-release` when players see no change (tooling, docs, tests), nothing for a fix.
   `release-now` is for crash fixes that shouldn't wait. pr_ready suggests one.
 
-Who reviews and merges: the Horizon Team, on CI for ordinary pull requests; risky ones (saves, network, world
-generation, the launcher's updates) wait for a local proof first ([merging](docs/release-flow.md#merging)).
-
 Every merge to main is released automatically ([release flow](docs/release-flow.md)), so main always stays playable.
 How agents, checks, releases and signed updates keep this safe: [security](docs/security.md).
 
@@ -118,5 +98,5 @@ new pushes, we add it again.
 
 ## Talk to us
 
-[Discord](https://discord.gg/HcTeMZxe5E) for questions and ideas, [issues](https://github.com/horizon-rust/horizon/issues)
-for bugs. To take something on, `/claim` its issue ([above](#claim-before-you-start)).
+[Discord](https://discord.gg/HcTeMZxe5E) for questions and ideas, [issues](https://github.com/ludovic111/horizon/issues)
+for bugs. If you want to take something on, say so in its issue so nobody else starts the same work.

Cargo.toml

@@ -8,10 +8,7 @@ members = [
     "crates/horizon-world",
     "crates/horizon-client",
     "crates/horizon-client-core",
-    "crates/horizon-client-input",
-    "crates/horizon-client-render",
     "crates/horizon-command",
-    "crates/horizon-items",
     "crates/horizon-server-files",
     "crates/horizon-server",
     "crates/horizon-bots",
@@ -23,13 +20,28 @@ members = [
     "crates/horizon-bench",
     "crates/horizon-friends",
     "crates/horizon-relay",
+    "crates/horizon-mod-sdk",
     "crates/horizon-mods",
+    "crates/horizon-mods/tests/guest",
+    "crates/horizon-mods/tests/ui_guest",
     "crates/cargo-horizon-mod",
     "crates/horizon-port-pack",
     "crates/horizon-shaders",
     "crates/horizon-shader-api",
     "crates/horizon-release-sign",
+    "crates/horizon-mod-sdk/examples/coords-hud",
+    "crates/horizon-mod-sdk/examples/coords-hud-lua",
+    "crates/horizon-mod-sdk/examples/predator-missile",
+    "crates/horizon-mod-sdk/examples/welcome",
+    "crates/horizon-mod-sdk/examples/beacons",
+    "mods/official/fps-overlay",
+    "mods/official/keystrokes",
+    "mods/official/far-view",
+    "mods/official/minimap",
+    "mods/official/zoom",
     "xtask",
+    "mods/official/recipes",
+    "crates/horizon-mod-lua",
 ]
 resolver = "2"
 
@@ -49,10 +61,8 @@ large_enum_variant = "allow"
 # wgpu-hal 30.0.1 with gfx-rs/wgpu#10124: wgpu 30 creates a Vulkan descriptor
 # pool with no pool sizes while it creates the device, which Vulkan allows only
 # since 1.3.215, and Intel's Windows driver for 6th-10th gen iGPUs (HD 520/530,
-# UHD 620/630) crashes on it with an access violation (#746). It also fixes the
-# Metal backend's lookup of the CoreGraphics HDR colour space names, which handed
-# CoreGraphics a symbol's address as the string and crashed HDR output on macOS.
-# Drop this and the folder once a wgpu release has both fixes.
+# UHD 620/630) crashes on it with an access violation (#746). Drop this and the
+# folder once a wgpu release has the fix.
 [patch.crates-io]
 wgpu-hal = { path = "third_party/wgpu-hal" }
 

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Ludovic Marie and the Horizon contributors
+Copyright (c) 2026 Ludovic
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,13 +1,12 @@
 <p align="center">
-  <img src="docs/media/banner.webp" alt="Horizon: Minecraft: Java Edition 26.3, rewritten in Rust and checked against vanilla by more than 300 differential harnesses" width="100%">
+  <img src="docs/media/banner.webp" alt="Horizon: Minecraft: Java Edition 26.3, rewritten in Rust and checked against vanilla by 281 differential harnesses" 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>
+  <a href="https://github.com/ludovic111/horizon/actions/workflows/ci.yml"><img src="https://github.com/ludovic111/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-833%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>
 </p>
@@ -16,7 +15,7 @@
   <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://github.com/ludovic111/horizon/releases"><b>Release notes</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>
@@ -24,15 +23,15 @@
 
 # Horizon
 
-Horizon is Minecraft: Java Edition 26.3 rewritten in Rust: a native game that reads the same worlds, follows the same rules and generates the same terrain as the Java game, and is checked against it by more than 300 differential harnesses. You play it through a small launcher, on the files from your own copy of Minecraft. It is free, open source and unofficial.
+Horizon is Minecraft: Java Edition 26.3 rewritten in Rust: a native game that reads the same worlds, follows the same rules and generates the same terrain as the Java game, and is checked against it by 281 differential harnesses. You play it through a small launcher, on the files from your own copy of Minecraft. It is free, open source and unofficial.
 
 > Not an official Minecraft product. Not approved by or associated with Mojang or Microsoft. Horizon contains no Minecraft code, assets or data: you need your own legally obtained copy of Minecraft: Java Edition 26.3.
 
 ## Download
 
-Horizon is installed through **the Horizon launcher**. Get it from [playhorizon.dev](https://playhorizon.dev) (the Download button picks your system) or from [the launcher releases](https://github.com/horizon-rust/horizon/releases?q=launcher-v&expanded=true), for Linux x86-64, macOS on Apple Silicon or Windows x64. The launcher installs the game and keeps it up to date with each new build (Horizon ships on one channel, the Nightly), prepares its files from your copy of Minecraft (your own install, or downloaded from Mojang for your account), and updates itself.
+Horizon is installed through **the Horizon launcher**. Get it from [playhorizon.dev](https://playhorizon.dev) (the Download button picks your system) or from [the launcher releases](https://github.com/ludovic111/horizon/releases?q=launcher-v&expanded=true), for Linux x86-64, macOS on Apple Silicon or Windows x64. The launcher installs and updates the game, prepares its files from your own copy of Minecraft, and updates itself.
 
-**You need** a Microsoft account that owns Minecraft: Java Edition (the launcher signs in with it, as other launchers do; see [Microsoft account](docs/microsoft-account.md)) and a GPU with Vulkan or OpenGL 3.3 on Linux, Vulkan or DirectX 12 on Windows, or any Apple Silicon Mac. Nothing else: with no Minecraft on your computer, Play downloads 26.3 and the Java it needs from Mojang for your account, as the official launcher does, then prepares it once. An install you already have (the official launcher, Prism, MultiMC and other launchers all work) is used instead. Step by step, with macOS's first-open prompt and the first launch: [Install and first launch](https://playhorizon.dev/docs/install).
+**You need** Minecraft: Java Edition 26.3, played once (the official launcher, Prism, MultiMC and other launchers all work); a Java 25 runtime, for the one-time preparation; and a GPU with Vulkan on Linux and Windows, or any Apple Silicon Mac. Step by step, with macOS's first-open prompt and the first launch: [Install and first launch](https://playhorizon.dev/docs/install).
 
 <table>
   <tr>
@@ -47,9 +46,9 @@ The [documentation](https://playhorizon.dev/docs/) covers each of these.
 
 - **The game:** singleplayer with vanilla's world generation, mobs, villagers, raids, redstone, every command, the HUD and the recipe book, on saves in vanilla's format. Worlds from 1.8 to 26.2 are upgraded as vanilla does. [Status table](#project-status).
 - **Horizon's own extras:** new menus (vanilla's are one setting away), graphics presets, distant terrain up to 1024 chunks, controller support, optional zoom, minimap and more, all off by default where they would change the vanilla look. See [Settings](https://playhorizon.dev/docs/settings).
-- **Resource packs and data packs:** resource packs work, and data packs load functions, predicates, item modifiers and world generation, taller levels included (vanilla's biomes for now).
-- **Playing with others:** invite friends from the pause menu's Friends button with a code, Open to LAN, and joining servers, online-mode ones with the Microsoft account the launcher signs in with. See [Multiplayer](https://playhorizon.dev/docs/multiplayer).
-- **Mods:** content mods add blocks, items and data, and native mods change the game's own Rust code, built by the launcher on your copy, with no Rust to install. Horizon's own (Zoom, FPS Counter, Keystrokes, Minimap, Recipes and Coordinates HUD) are native mods. Java mod jars do not run in Horizon. See [Mods and data packs](https://playhorizon.dev/docs/mods).
+- **Resource packs and data packs:** resource packs work, and data packs load functions, predicates and item modifiers.
+- **Playing with others:** invite friends from the pause menu's Friends button with a code, Open to LAN, and joining offline-mode servers. Horizon cannot sign in to a Microsoft account yet, so it cannot join servers that check accounts. See [Multiplayer](https://playhorizon.dev/docs/multiplayer).
+- **Mods:** Horizon has its own mod system (Rust compiled to WebAssembly). Java mod jars do not run. See [Mods and data packs](https://playhorizon.dev/docs/mods).
 
 Screenshots, captured in the Rust client itself with vanilla assets and no mods or shaders:
 
@@ -94,13 +93,13 @@ Commands block until the action is done and reply with what happened; errors are
 
 For developers. Requirements: Rust 1.90 or newer, Python 3.10 or newer, JDK 25, and on Linux the ALSA and udev development headers (`libasound2-dev libudev-dev` on Debian and Ubuntu). Development and the vanilla harnesses run on Linux.
 
-Horizon contains no game files, and `horizon-prepare` never downloads them (the launcher downloads them from Mojang only for a signed-in account that owns the game). It builds its resources from **your own copy** of Minecraft: Java Edition 26.3, verified against the checksums in `research-lock.json`:
+Horizon contains no game files and never downloads them. It builds its resources from **your own copy** of Minecraft: Java Edition 26.3, verified against the checksums in `research-lock.json`:
 
 1. **Client:** install Java Edition with the official launcher and play 26.3 once. Horizon reads `versions/26.3/`, `libraries/` and `assets/` from the launcher's game directory (`~/.minecraft` on Linux). If yours lives elsewhere, pass `--minecraft-dir` or set `HORIZON_MINECRAFT_DIR`.
 2. **Server jar:** the 26.3 server jar, from the `downloads.server.url` in your launcher's `versions/26.3/26.3.json` (or [minecraft.net/download/server](https://www.minecraft.net/en-us/download/server) while 26.3 is the current release). Pass it with `--server-jar` or set `HORIZON_SERVER_JAR`. It is only needed the first time.
 
 ```sh
-git clone https://github.com/horizon-rust/horizon.git
+git clone https://github.com/ludovic111/horizon.git
 cd horizon
 cargo run --release -p horizon-prepare -- --prepare --server-jar ~/Downloads/server.jar   # needs JDK 25
 cargo run --release -p horizon-prepare -- sounds   # optional: sounds from your launcher install
@@ -128,8 +127,6 @@ It runs rustfmt, clippy with warnings denied, the tests of the crates you touche
 
 ## Project status
 
-**Player-visible gaps: 833 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: Screens, HUD and client packets [197](https://github.com/horizon-rust/horizon/issues/3518); Entity and block rendering, models [129](https://github.com/horizon-rust/horizon/issues/3519); Animals [110](https://github.com/horizon-rust/horizon/issues/3512); Server and players on the server [106](https://github.com/horizon-rust/horizon/issues/3520); Blocks, redstone and fluids [86](https://github.com/horizon-rust/horizon/issues/3516); Entities, projectiles, vehicles and decorations [64](https://github.com/horizon-rust/horizon/issues/3514); Monsters and bosses [53](https://github.com/horizon-rust/horizon/issues/3513); Mob AI, villagers and raids [35](https://github.com/horizon-rust/horizon/issues/3521); World, world generation and saves [32](https://github.com/horizon-rust/horizon/issues/3517); Items, enchantments and inventories [21](https://github.com/horizon-rust/horizon/issues/3515). This number goes down as gaps close (`tools/parity_gaps.py`); the harness results below say that what is tested matches.
-
 The table below is the project's own audit of each subsystem. Every subsystem now matches vanilla in every harness that compares it. 100% means 100% of what the harnesses compare, not proof that nothing else differs. The remaining known differences are listed below.
 
 ### Java parity: 100%
@@ -142,11 +139,6 @@ average; `tests/test_parity.py` keeps it in sync with this table. Last audited
 rerun whenever one of its inputs changed, and the Mac mini now runs every one of
 them too (Rust uses Java's own float maths on each platform).
 
-The harnesses measure behaviour. A second measure is method by method: the [port ledger](tools/port_ledger.py)
-lists every method of vanilla 26.3 next to the Rust functions that port it, with a verdict for each one
-(ported, folded into another function, missing, or needing no port), and the untested ports. Run
-`python3 tools/port_ledger.py build`, then `coverage`, with the vanilla data in `.local/`.
-
 | Subsystem | Score | Main gaps |
 | --- | ---: | --- |
 | Window, input and game loop | 1 | None: the game loop, options, camera, auto-jump, toggle sprint/sneak, local input and the frame limiter match vanilla |
@@ -166,7 +158,7 @@ lists every method of vanilla 26.3 next to the Rust functions that port it, with
 
 ### 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.
+Horizon can't sign in to a Microsoft account yet, so it can't join online-mode servers (it joins offline-mode ones); skins served over https show the default skin unless already cached; pack icons show the unknown-pack texture in game; the creative hotbar keys (C/X) aren't wired to the hotbar loader; item tooltips lack attribute lines.
 
 ## Licence
 

benchmarks/perf/horizon-win-9800x3d-5080-rd16.json

@@ -1,773 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-10-29T01:13:01Z",
- "app": {
-  "name": "horizon-client",
-  "version": "v0.2.97",
-  "commit": null
- },
- "hardware": {
-  "os": "windows",
-  "arch": "x86_64",
-  "cpu_threads": 16,
-  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
-  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
-  "ram_mb": 95943,
-  "gpu": {
-   "name": "NVIDIA GeForce RTX 5080",
-   "vendor": "nvidia",
-   "driver": "NVIDIA 617.42",
-   "backend": "vulkan",
-   "kind": "discrete"
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 16,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": false,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 3158.208,
-   "stdev": 215.77,
-   "min": 3023.046,
-   "max": 3407.049,
-   "ci95": 536.046
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 7170.164,
-   "stdev": 557.958,
-   "min": 6703.242,
-   "max": 7788.08,
-   "ci95": 1386.157
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 1694.647,
-   "stdev": 41.285,
-   "min": 1653.122,
-   "max": 1735.687,
-   "ci95": 102.566
-  },
-  "chunks.village.meshed_count": {
-   "n": 3,
-   "mean": 23544.0,
-   "stdev": 47.127,
-   "min": 23495.0,
-   "max": 23589.0,
-   "ci95": 117.081
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 1711.652,
-   "stdev": 77.412,
-   "min": 1623.403,
-   "max": 1768.093,
-   "ci95": 192.317
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 593.407,
-   "stdev": 32.279,
-   "min": 571.485,
-   "max": 630.473,
-   "ci95": 80.191
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 358.473,
-   "stdev": 27.832,
-   "min": 326.35,
-   "max": 375.353,
-   "ci95": 69.143
-  },
-  "memory.village.gpu_mb": {
-   "n": 3,
-   "mean": 631.813,
-   "stdev": 8.381,
-   "min": 626.803,
-   "max": 641.489,
-   "ci95": 20.822
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 2521.363,
-   "stdev": 291.624,
-   "min": 2336.881,
-   "max": 2857.57,
-   "ci95": 724.493
-  },
-  "chunks.forest.meshed_count": {
-   "n": 3,
-   "mean": 27346.667,
-   "stdev": 57.934,
-   "min": 27306.0,
-   "max": 27413.0,
-   "ci95": 143.927
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 2423.783,
-   "stdev": 55.746,
-   "min": 2386.353,
-   "max": 2487.851,
-   "ci95": 138.493
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 709.165,
-   "stdev": 66.309,
-   "min": 638.666,
-   "max": 770.286,
-   "ci95": 164.734
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 401.039,
-   "stdev": 40.413,
-   "min": 354.472,
-   "max": 426.929,
-   "ci95": 100.399
-  },
-  "memory.forest.gpu_mb": {
-   "n": 3,
-   "mean": 705.008,
-   "stdev": 6.062,
-   "min": 698.466,
-   "max": 710.435,
-   "ci95": 15.06
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 2094.909,
-   "stdev": 521.225,
-   "min": 1758.024,
-   "max": 2695.274,
-   "ci95": 1294.9
-  },
-  "chunks.ocean.meshed_count": {
-   "n": 3,
-   "mean": 24312.667,
-   "stdev": 261.934,
-   "min": 24116.0,
-   "max": 24610.0,
-   "ci95": 650.732
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 2201.125,
-   "stdev": 73.595,
-   "min": 2153.6,
-   "max": 2285.897,
-   "ci95": 182.834
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 553.968,
-   "stdev": 100.955,
-   "min": 445.599,
-   "max": 645.355,
-   "ci95": 250.806
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 325.078,
-   "stdev": 131.154,
-   "min": 177.4,
-   "max": 427.981,
-   "ci95": 325.831
-  },
-  "memory.ocean.gpu_mb": {
-   "n": 3,
-   "mean": 652.944,
-   "stdev": 5.177,
-   "min": 647.51,
-   "max": 657.818,
-   "ci95": 12.862
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 3304.58,
-   "stdev": 134.041,
-   "min": 3155.996,
-   "max": 3416.409,
-   "ci95": 333.003
-  },
-  "chunks.mountain.meshed_count": {
-   "n": 3,
-   "mean": 26591.0,
-   "stdev": 57.472,
-   "min": 26525.0,
-   "max": 26630.0,
-   "ci95": 142.779
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 1961.086,
-   "stdev": 39.725,
-   "min": 1921.241,
-   "max": 2000.69,
-   "ci95": 98.69
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 536.973,
-   "stdev": 38.828,
-   "min": 495.61,
-   "max": 572.635,
-   "ci95": 96.461
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 296.586,
-   "stdev": 30.236,
-   "min": 275.859,
-   "max": 331.281,
-   "ci95": 75.118
-  },
-  "memory.mountain.gpu_mb": {
-   "n": 3,
-   "mean": 896.941,
-   "stdev": 5.177,
-   "min": 891.506,
-   "max": 901.814,
-   "ci95": 12.862
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 1458.578,
-   "stdev": 3.229,
-   "min": 1455.32,
-   "max": 1461.777,
-   "ci95": 8.022
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 1236.28,
-   "stdev": 4.869,
-   "min": 1230.701,
-   "max": 1239.672,
-   "ci95": 12.096
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 21218,
-   "seconds": 12.0,
-   "avg_fps": 1768.093,
-   "low_1pct_fps": 630.473,
-   "low_01pct_fps": 375.353,
-   "p50_ms": 0.537,
-   "p95_ms": 0.846,
-   "p99_ms": 1.222,
-   "p999_ms": 2.081,
-   "max_ms": 6.256,
-   "cpu_p50_ms": 0.38,
-   "gpu_p50_ms": 0.104,
-   "histogram": [
-    20695,
-    499,
-    22,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 19482,
-   "seconds": 12.001,
-   "avg_fps": 1623.403,
-   "low_1pct_fps": 578.262,
-   "low_01pct_fps": 373.717,
-   "p50_ms": 0.586,
-   "p95_ms": 0.95,
-   "p99_ms": 1.357,
-   "p999_ms": 2.158,
-   "max_ms": 7.35,
-   "cpu_p50_ms": 0.445,
-   "gpu_p50_ms": 0.104,
-   "histogram": [
-    18729,
-    713,
-    38,
-    1,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 20922,
-   "seconds": 12.0,
-   "avg_fps": 1743.46,
-   "low_1pct_fps": 571.485,
-   "low_01pct_fps": 326.35,
-   "p50_ms": 0.526,
-   "p95_ms": 0.883,
-   "p99_ms": 1.313,
-   "p999_ms": 2.14,
-   "max_ms": 12.027,
-   "cpu_p50_ms": 0.379,
-   "gpu_p50_ms": 0.104,
-   "histogram": [
-    20308,
-    582,
-    28,
-    2,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 29855,
-   "seconds": 12.0,
-   "avg_fps": 2487.851,
-   "low_1pct_fps": 770.286,
-   "low_01pct_fps": 421.717,
-   "p50_ms": 0.365,
-   "p95_ms": 0.619,
-   "p99_ms": 0.948,
-   "p999_ms": 1.717,
-   "max_ms": 9.446,
-   "cpu_p50_ms": 0.232,
-   "gpu_p50_ms": 0.157,
-   "histogram": [
-    29607,
-    233,
-    13,
-    0,
-    0,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 28766,
-   "seconds": 12.0,
-   "avg_fps": 2397.145,
-   "low_1pct_fps": 718.542,
-   "low_01pct_fps": 426.929,
-   "p50_ms": 0.374,
-   "p95_ms": 0.662,
-   "p99_ms": 1.016,
-   "p999_ms": 1.858,
-   "max_ms": 6.379,
-   "cpu_p50_ms": 0.239,
-   "gpu_p50_ms": 0.157,
-   "histogram": [
-    28457,
-    293,
-    14,
-    0,
-    0,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 28637,
-   "seconds": 12.0,
-   "avg_fps": 2386.353,
-   "low_1pct_fps": 638.666,
-   "low_01pct_fps": 354.472,
-   "p50_ms": 0.373,
-   "p95_ms": 0.704,
-   "p99_ms": 1.159,
-   "p999_ms": 1.952,
-   "max_ms": 14.388,
-   "cpu_p50_ms": 0.233,
-   "gpu_p50_ms": 0.157,
-   "histogram": [
-    28198,
-    415,
-    18,
-    5,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 25968,
-   "seconds": 12.001,
-   "avg_fps": 2163.877,
-   "low_1pct_fps": 570.949,
-   "low_01pct_fps": 369.854,
-   "p50_ms": 0.408,
-   "p95_ms": 0.767,
-   "p99_ms": 1.339,
-   "p999_ms": 2.38,
-   "max_ms": 3.329,
-   "cpu_p50_ms": 0.271,
-   "gpu_p50_ms": 0.141,
-   "histogram": [
-    25383,
-    534,
-    47,
-    4,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 25843,
-   "seconds": 12.0,
-   "avg_fps": 2153.6,
-   "low_1pct_fps": 445.599,
-   "low_01pct_fps": 177.4,
-   "p50_ms": 0.413,
-   "p95_ms": 0.725,
-   "p99_ms": 1.309,
-   "p999_ms": 3.451,
-   "max_ms": 12.071,
-   "cpu_p50_ms": 0.275,
-   "gpu_p50_ms": 0.142,
-   "histogram": [
-    25375,
-    373,
-    56,
-    22,
-    1,
-    7,
-    3,
-    5,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 27431,
-   "seconds": 12.0,
-   "avg_fps": 2285.897,
-   "low_1pct_fps": 645.355,
-   "low_01pct_fps": 427.981,
-   "p50_ms": 0.388,
-   "p95_ms": 0.693,
-   "p99_ms": 1.163,
-   "p999_ms": 2.041,
-   "max_ms": 3.068,
-   "cpu_p50_ms": 0.254,
-   "gpu_p50_ms": 0.141,
-   "histogram": [
-    27036,
-    363,
-    31,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 23536,
-   "seconds": 12.0,
-   "avg_fps": 1961.326,
-   "low_1pct_fps": 542.675,
-   "low_01pct_fps": 331.281,
-   "p50_ms": 0.436,
-   "p95_ms": 0.856,
-   "p99_ms": 1.425,
-   "p999_ms": 2.22,
-   "max_ms": 9.458,
-   "cpu_p50_ms": 0.296,
-   "gpu_p50_ms": 0.14,
-   "histogram": [
-    22819,
-    671,
-    40,
-    5,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 23056,
-   "seconds": 12.001,
-   "avg_fps": 1921.241,
-   "low_1pct_fps": 495.61,
-   "low_01pct_fps": 282.617,
-   "p50_ms": 0.44,
-   "p95_ms": 0.911,
-   "p99_ms": 1.516,
-   "p999_ms": 2.543,
-   "max_ms": 14.342,
-   "cpu_p50_ms": 0.299,
-   "gpu_p50_ms": 0.141,
-   "histogram": [
-    22198,
-    783,
-    65,
-    7,
-    0,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 24009,
-   "seconds": 12.0,
-   "avg_fps": 2000.69,
-   "low_1pct_fps": 572.635,
-   "low_01pct_fps": 275.859,
-   "p50_ms": 0.436,
-   "p95_ms": 0.819,
-   "p99_ms": 1.274,
-   "p999_ms": 2.085,
-   "max_ms": 14.003,
-   "cpu_p50_ms": 0.297,
-   "gpu_p50_ms": 0.14,
-   "histogram": [
-    23421,
-    560,
-    22,
-    0,
-    1,
-    0,
-    2,
-    2,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  }
- ],
- "label": "horizon-win-9800x3d-5080"
-}

benchmarks/perf/horizon-win-9800x3d-5080-rd32.json

@@ -1,773 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-10-29T18:55:59Z",
- "app": {
-  "name": "horizon-client",
-  "version": "v0.2.97",
-  "commit": null
- },
- "hardware": {
-  "os": "windows",
-  "arch": "x86_64",
-  "cpu_threads": 16,
-  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
-  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
-  "ram_mb": 95943,
-  "gpu": {
-   "name": "NVIDIA GeForce RTX 5080",
-   "vendor": "nvidia",
-   "driver": "NVIDIA 617.42",
-   "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,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 2897.812,
-   "stdev": 82.455,
-   "min": 2844.677,
-   "max": 2992.8,
-   "ci95": 204.846
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 10503.454,
-   "stdev": 493.592,
-   "min": 9934.491,
-   "max": 10816.992,
-   "ci95": 1226.251
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 3717.47,
-   "stdev": 1330.649,
-   "min": 2942.872,
-   "max": 5253.954,
-   "ci95": 3305.783
-  },
-  "chunks.village.meshed_count": {
-   "n": 3,
-   "mean": 47525.333,
-   "stdev": 1369.122,
-   "min": 46133.0,
-   "max": 48870.0,
-   "ci95": 3401.363
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 1163.541,
-   "stdev": 3.485,
-   "min": 1159.52,
-   "max": 1165.693,
-   "ci95": 8.658
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 415.992,
-   "stdev": 15.742,
-   "min": 399.062,
-   "max": 430.188,
-   "ci95": 39.108
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 215.549,
-   "stdev": 34.678,
-   "min": 177.857,
-   "max": 246.101,
-   "ci95": 86.151
-  },
-  "memory.village.gpu_mb": {
-   "n": 3,
-   "mean": 1833.432,
-   "stdev": 4.415,
-   "min": 1828.334,
-   "max": 1835.997,
-   "ci95": 10.969
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 5455.049,
-   "stdev": 593.897,
-   "min": 4973.659,
-   "max": 6118.723,
-   "ci95": 1475.44
-  },
-  "chunks.forest.meshed_count": {
-   "n": 3,
-   "mean": 82758.0,
-   "stdev": 413.547,
-   "min": 82487.0,
-   "max": 83234.0,
-   "ci95": 1027.39
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 1389.46,
-   "stdev": 28.128,
-   "min": 1371.096,
-   "max": 1421.843,
-   "ci95": 69.88
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 504.377,
-   "stdev": 13.251,
-   "min": 492.444,
-   "max": 518.637,
-   "ci95": 32.919
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 329.682,
-   "stdev": 47.451,
-   "min": 294.872,
-   "max": 383.732,
-   "ci95": 117.885
-  },
-  "memory.forest.gpu_mb": {
-   "n": 3,
-   "mean": 1985.175,
-   "stdev": 6.354,
-   "min": 1978.907,
-   "max": 1991.612,
-   "ci95": 15.786
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 4504.145,
-   "stdev": 745.393,
-   "min": 3650.589,
-   "max": 5026.8,
-   "ci95": 1851.809
-  },
-  "chunks.ocean.meshed_count": {
-   "n": 3,
-   "mean": 74927.333,
-   "stdev": 399.375,
-   "min": 74476.0,
-   "max": 75235.0,
-   "ci95": 992.182
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 1188.639,
-   "stdev": 10.807,
-   "min": 1177.005,
-   "max": 1198.365,
-   "ci95": 26.849
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 154.773,
-   "stdev": 3.712,
-   "min": 151.38,
-   "max": 158.738,
-   "ci95": 9.223
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 67.809,
-   "stdev": 3.032,
-   "min": 65.903,
-   "max": 71.305,
-   "ci95": 7.532
-  },
-  "memory.ocean.gpu_mb": {
-   "n": 3,
-   "mean": 2084.845,
-   "stdev": 9.674,
-   "min": 2074.009,
-   "max": 2092.615,
-   "ci95": 24.034
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 9048.431,
-   "stdev": 344.33,
-   "min": 8821.41,
-   "max": 9444.624,
-   "ci95": 855.432
-  },
-  "chunks.mountain.meshed_count": {
-   "n": 3,
-   "mean": 89659.667,
-   "stdev": 87.123,
-   "min": 89561.0,
-   "max": 89726.0,
-   "ci95": 216.442
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 1085.847,
-   "stdev": 13.819,
-   "min": 1070.378,
-   "max": 1096.974,
-   "ci95": 34.332
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 257.7,
-   "stdev": 31.437,
-   "min": 224.366,
-   "max": 286.814,
-   "ci95": 78.101
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 107.783,
-   "stdev": 14.883,
-   "min": 91.541,
-   "max": 120.768,
-   "ci95": 36.975
-  },
-  "memory.mountain.gpu_mb": {
-   "n": 3,
-   "mean": 2708.833,
-   "stdev": 9.674,
-   "min": 2697.997,
-   "max": 2716.603,
-   "ci95": 24.034
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 2044.895,
-   "stdev": 10.562,
-   "min": 2032.875,
-   "max": 2052.691,
-   "ci95": 26.238
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 1730.107,
-   "stdev": 14.764,
-   "min": 1717.52,
-   "max": 1746.357,
-   "ci95": 36.678
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 13986,
-   "seconds": 12.001,
-   "avg_fps": 1165.41,
-   "low_1pct_fps": 399.062,
-   "low_01pct_fps": 177.857,
-   "p50_ms": 0.822,
-   "p95_ms": 1.21,
-   "p99_ms": 1.691,
-   "p999_ms": 3.499,
-   "max_ms": 13.089,
-   "cpu_p50_ms": 0.665,
-   "gpu_p50_ms": 0.193,
-   "histogram": [
-    12380,
-    1527,
-    58,
-    13,
-    2,
-    2,
-    1,
-    2,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 13915,
-   "seconds": 12.001,
-   "avg_fps": 1159.52,
-   "low_1pct_fps": 430.188,
-   "low_01pct_fps": 246.101,
-   "p50_ms": 0.809,
-   "p95_ms": 1.212,
-   "p99_ms": 1.702,
-   "p999_ms": 3.291,
-   "max_ms": 6.894,
-   "cpu_p50_ms": 0.648,
-   "gpu_p50_ms": 0.192,
-   "histogram": [
-    11996,
-    1839,
-    59,
-    17,
-    2,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 13989,
-   "seconds": 12.001,
-   "avg_fps": 1165.693,
-   "low_1pct_fps": 418.725,
-   "low_01pct_fps": 222.688,
-   "p50_ms": 0.816,
-   "p95_ms": 1.22,
-   "p99_ms": 1.692,
-   "p999_ms": 3.264,
-   "max_ms": 7.781,
-   "cpu_p50_ms": 0.669,
-   "gpu_p50_ms": 0.193,
-   "histogram": [
-    12321,
-    1578,
-    72,
-    11,
-    2,
-    4,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 17063,
-   "seconds": 12.001,
-   "avg_fps": 1421.843,
-   "low_1pct_fps": 502.049,
-   "low_01pct_fps": 294.872,
-   "p50_ms": 0.666,
-   "p95_ms": 0.935,
-   "p99_ms": 1.549,
-   "p999_ms": 2.692,
-   "max_ms": 6.831,
-   "cpu_p50_ms": 0.533,
-   "gpu_p50_ms": 0.362,
-   "histogram": [
-    16417,
-    596,
-    40,
-    7,
-    2,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 16454,
-   "seconds": 12.001,
-   "avg_fps": 1371.096,
-   "low_1pct_fps": 492.444,
-   "low_01pct_fps": 310.443,
-   "p50_ms": 0.688,
-   "p95_ms": 0.979,
-   "p99_ms": 1.556,
-   "p999_ms": 2.693,
-   "max_ms": 4.596,
-   "cpu_p50_ms": 0.553,
-   "gpu_p50_ms": 0.36,
-   "histogram": [
-    15692,
-    697,
-    57,
-    7,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 16506,
-   "seconds": 12.001,
-   "avg_fps": 1375.442,
-   "low_1pct_fps": 518.637,
-   "low_01pct_fps": 383.732,
-   "p50_ms": 0.675,
-   "p95_ms": 1.017,
-   "p99_ms": 1.605,
-   "p999_ms": 2.369,
-   "max_ms": 3.201,
-   "cpu_p50_ms": 0.54,
-   "gpu_p50_ms": 0.364,
-   "histogram": [
-    15628,
-    833,
-    44,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 14381,
-   "seconds": 12.001,
-   "avg_fps": 1198.365,
-   "low_1pct_fps": 154.2,
-   "low_01pct_fps": 66.219,
-   "p50_ms": 0.731,
-   "p95_ms": 1.023,
-   "p99_ms": 3.003,
-   "p999_ms": 12.478,
-   "max_ms": 18.863,
-   "cpu_p50_ms": 0.596,
-   "gpu_p50_ms": 0.315,
-   "histogram": [
-    13586,
-    546,
-    105,
-    60,
-    13,
-    13,
-    8,
-    16,
-    8,
-    11,
-    5,
-    7,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 14287,
-   "seconds": 12.0,
-   "avg_fps": 1190.548,
-   "low_1pct_fps": 158.738,
-   "low_01pct_fps": 71.305,
-   "p50_ms": 0.741,
-   "p95_ms": 1.041,
-   "p99_ms": 2.9,
-   "p999_ms": 12.0,
-   "max_ms": 17.23,
-   "cpu_p50_ms": 0.602,
-   "gpu_p50_ms": 0.315,
-   "histogram": [
-    13450,
-    591,
-    109,
-    57,
-    13,
-    8,
-    10,
-    11,
-    14,
-    10,
-    7,
-    6,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 14124,
-   "seconds": 12.0,
-   "avg_fps": 1177.005,
-   "low_1pct_fps": 151.38,
-   "low_01pct_fps": 65.903,
-   "p50_ms": 0.739,
-   "p95_ms": 1.096,
-   "p99_ms": 2.928,
-   "p999_ms": 11.884,
-   "max_ms": 19.375,
-   "cpu_p50_ms": 0.604,
-   "gpu_p50_ms": 0.314,
-   "histogram": [
-    13052,
-    822,
-    114,
-    54,
-    16,
-    8,
-    4,
-    14,
-    11,
-    15,
-    3,
-    8,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 12845,
-   "seconds": 12.0,
-   "avg_fps": 1070.378,
-   "low_1pct_fps": 224.366,
-   "low_01pct_fps": 91.541,
-   "p50_ms": 0.825,
-   "p95_ms": 1.362,
-   "p99_ms": 2.325,
-   "p999_ms": 9.621,
-   "max_ms": 13.309,
-   "cpu_p50_ms": 0.689,
-   "gpu_p50_ms": 0.307,
-   "histogram": [
-    10937,
-    1699,
-    143,
-    25,
-    5,
-    6,
-    4,
-    8,
-    8,
-    8,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 13083,
-   "seconds": 12.001,
-   "avg_fps": 1090.188,
-   "low_1pct_fps": 261.921,
-   "low_01pct_fps": 111.039,
-   "p50_ms": 0.816,
-   "p95_ms": 1.335,
-   "p99_ms": 2.14,
-   "p999_ms": 8.222,
-   "max_ms": 11.95,
-   "cpu_p50_ms": 0.681,
-   "gpu_p50_ms": 0.306,
-   "histogram": [
-    11105,
-    1812,
-    112,
-    21,
-    5,
-    5,
-    5,
-    6,
-    11,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 13164,
-   "seconds": 12.0,
-   "avg_fps": 1096.974,
-   "low_1pct_fps": 286.814,
-   "low_01pct_fps": 120.768,
-   "p50_ms": 0.822,
-   "p95_ms": 1.307,
-   "p99_ms": 1.989,
-   "p999_ms": 7.701,
-   "max_ms": 9.429,
-   "cpu_p50_ms": 0.687,
-   "gpu_p50_ms": 0.307,
-   "histogram": [
-    11280,
-    1758,
-    82,
-    13,
-    5,
-    5,
-    6,
-    8,
-    7,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  }
- ],
- "label": "horizon-win-9800x3d-5080"
-}

benchmarks/perf/horizon-win-9800x3d-5080-rd8.json

@@ -1,773 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-10-29T18:37:03Z",
- "app": {
-  "name": "horizon-client",
-  "version": "v0.2.97",
-  "commit": null
- },
- "hardware": {
-  "os": "windows",
-  "arch": "x86_64",
-  "cpu_threads": 16,
-  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
-  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
-  "ram_mb": 95943,
-  "gpu": {
-   "name": "NVIDIA GeForce RTX 5080",
-   "vendor": "nvidia",
-   "driver": "NVIDIA 617.42",
-   "backend": "vulkan",
-   "kind": "discrete"
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 8,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": false,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 2950.343,
-   "stdev": 162.732,
-   "min": 2822.925,
-   "max": 3133.657,
-   "ci95": 404.282
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 6135.1,
-   "stdev": 863.831,
-   "min": 5547.861,
-   "max": 7126.98,
-   "ci95": 2146.05
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 985.519,
-   "stdev": 28.184,
-   "min": 956.244,
-   "max": 1012.469,
-   "ci95": 70.019
-  },
-  "chunks.village.meshed_count": {
-   "n": 3,
-   "mean": 6908.0,
-   "stdev": 9.849,
-   "min": 6897.0,
-   "max": 6916.0,
-   "ci95": 24.468
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 2941.608,
-   "stdev": 79.283,
-   "min": 2850.416,
-   "max": 2994.188,
-   "ci95": 196.965
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 1271.318,
-   "stdev": 58.797,
-   "min": 1203.758,
-   "max": 1310.917,
-   "ci95": 146.072
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 839.261,
-   "stdev": 37.982,
-   "min": 795.415,
-   "max": 862.067,
-   "ci95": 94.36
-  },
-  "memory.village.gpu_mb": {
-   "n": 3,
-   "mean": 363.984,
-   "stdev": 0.926,
-   "min": 363.449,
-   "max": 365.053,
-   "ci95": 2.299
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 1350.752,
-   "stdev": 293.128,
-   "min": 1106.764,
-   "max": 1675.913,
-   "ci95": 728.23
-  },
-  "chunks.forest.meshed_count": {
-   "n": 3,
-   "mean": 8066.0,
-   "stdev": 108.885,
-   "min": 7986.0,
-   "max": 8190.0,
-   "ci95": 270.508
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 3494.693,
-   "stdev": 110.997,
-   "min": 3389.894,
-   "max": 3610.993,
-   "ci95": 275.755
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 1295.14,
-   "stdev": 159.638,
-   "min": 1148.468,
-   "max": 1465.171,
-   "ci95": 396.596
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 859.326,
-   "stdev": 119.845,
-   "min": 721.994,
-   "max": 942.743,
-   "ci95": 297.734
-  },
-  "memory.forest.gpu_mb": {
-   "n": 3,
-   "mean": 381.189,
-   "stdev": 5.222,
-   "min": 376.423,
-   "max": 386.77,
-   "ci95": 12.972
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 1123.386,
-   "stdev": 604.175,
-   "min": 734.302,
-   "max": 1819.414,
-   "ci95": 1500.976
-  },
-  "chunks.ocean.meshed_count": {
-   "n": 3,
-   "mean": 6613.0,
-   "stdev": 135.632,
-   "min": 6523.0,
-   "max": 6769.0,
-   "ci95": 336.955
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 3346.003,
-   "stdev": 59.312,
-   "min": 3303.535,
-   "max": 3413.77,
-   "ci95": 147.352
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 1357.991,
-   "stdev": 95.364,
-   "min": 1248.887,
-   "max": 1425.451,
-   "ci95": 236.917
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 911.822,
-   "stdev": 94.717,
-   "min": 802.528,
-   "max": 969.989,
-   "ci95": 235.308
-  },
-  "memory.ocean.gpu_mb": {
-   "n": 3,
-   "mean": 391.636,
-   "stdev": 5.435,
-   "min": 387.424,
-   "max": 397.771,
-   "ci95": 13.502
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 1588.954,
-   "stdev": 458.924,
-   "min": 1309.548,
-   "max": 2118.606,
-   "ci95": 1140.123
-  },
-  "chunks.mountain.meshed_count": {
-   "n": 3,
-   "mean": 7887.667,
-   "stdev": 41.041,
-   "min": 7862.0,
-   "max": 7935.0,
-   "ci95": 101.959
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 3375.623,
-   "stdev": 26.82,
-   "min": 3352.309,
-   "max": 3404.933,
-   "ci95": 66.629
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 1383.745,
-   "stdev": 67.628,
-   "min": 1324.071,
-   "max": 1457.203,
-   "ci95": 168.01
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 850.213,
-   "stdev": 103.149,
-   "min": 790.305,
-   "max": 969.318,
-   "ci95": 256.256
-  },
-  "memory.mountain.gpu_mb": {
-   "n": 3,
-   "mean": 448.64,
-   "stdev": 5.435,
-   "min": 444.428,
-   "max": 454.775,
-   "ci95": 13.502
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 1171.629,
-   "stdev": 0.337,
-   "min": 1171.398,
-   "max": 1172.016,
-   "ci95": 0.837
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 1082.078,
-   "stdev": 12.494,
-   "min": 1069.117,
-   "max": 1094.047,
-   "ci95": 31.04
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 35764,
-   "seconds": 12.0,
-   "avg_fps": 2980.22,
-   "low_1pct_fps": 1310.917,
-   "low_01pct_fps": 860.301,
-   "p50_ms": 0.317,
-   "p95_ms": 0.433,
-   "p99_ms": 0.633,
-   "p999_ms": 0.937,
-   "max_ms": 2.807,
-   "cpu_p50_ms": 0.192,
-   "gpu_p50_ms": 0.063,
-   "histogram": [
-    35741,
-    22,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 35931,
-   "seconds": 12.0,
-   "avg_fps": 2994.188,
-   "low_1pct_fps": 1299.278,
-   "low_01pct_fps": 795.415,
-   "p50_ms": 0.318,
-   "p95_ms": 0.428,
-   "p99_ms": 0.62,
-   "p999_ms": 0.943,
-   "max_ms": 5.797,
-   "cpu_p50_ms": 0.191,
-   "gpu_p50_ms": 0.063,
-   "histogram": [
-    35906,
-    23,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 34206,
-   "seconds": 12.0,
-   "avg_fps": 2850.416,
-   "low_1pct_fps": 1203.758,
-   "low_01pct_fps": 862.067,
-   "p50_ms": 0.326,
-   "p95_ms": 0.508,
-   "p99_ms": 0.705,
-   "p999_ms": 1.025,
-   "max_ms": 1.398,
-   "cpu_p50_ms": 0.196,
-   "gpu_p50_ms": 0.063,
-   "histogram": [
-    34167,
-    39,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 41800,
-   "seconds": 12.0,
-   "avg_fps": 3483.193,
-   "low_1pct_fps": 1271.782,
-   "low_01pct_fps": 913.242,
-   "p50_ms": 0.264,
-   "p95_ms": 0.415,
-   "p99_ms": 0.657,
-   "p999_ms": 0.935,
-   "max_ms": 1.482,
-   "cpu_p50_ms": 0.144,
-   "gpu_p50_ms": 0.075,
-   "histogram": [
-    41768,
-    32,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 43333,
-   "seconds": 12.0,
-   "avg_fps": 3610.993,
-   "low_1pct_fps": 1465.171,
-   "low_01pct_fps": 942.743,
-   "p50_ms": 0.263,
-   "p95_ms": 0.355,
-   "p99_ms": 0.561,
-   "p999_ms": 0.859,
-   "max_ms": 1.694,
-   "cpu_p50_ms": 0.143,
-   "gpu_p50_ms": 0.074,
-   "histogram": [
-    43310,
-    23,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 40679,
-   "seconds": 12.0,
-   "avg_fps": 3389.894,
-   "low_1pct_fps": 1148.468,
-   "low_01pct_fps": 721.994,
-   "p50_ms": 0.267,
-   "p95_ms": 0.446,
-   "p99_ms": 0.67,
-   "p999_ms": 1.183,
-   "max_ms": 2.434,
-   "cpu_p50_ms": 0.146,
-   "gpu_p50_ms": 0.076,
-   "histogram": [
-    40590,
-    87,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 39849,
-   "seconds": 12.0,
-   "avg_fps": 3320.704,
-   "low_1pct_fps": 1399.634,
-   "low_01pct_fps": 969.989,
-   "p50_ms": 0.281,
-   "p95_ms": 0.404,
-   "p99_ms": 0.601,
-   "p999_ms": 0.875,
-   "max_ms": 1.494,
-   "cpu_p50_ms": 0.159,
-   "gpu_p50_ms": 0.069,
-   "histogram": [
-    39831,
-    18,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 40966,
-   "seconds": 12.0,
-   "avg_fps": 3413.77,
-   "low_1pct_fps": 1425.451,
-   "low_01pct_fps": 962.948,
-   "p50_ms": 0.278,
-   "p95_ms": 0.372,
-   "p99_ms": 0.581,
-   "p999_ms": 0.857,
-   "max_ms": 1.576,
-   "cpu_p50_ms": 0.157,
-   "gpu_p50_ms": 0.069,
-   "histogram": [
-    40947,
-    19,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 39643,
-   "seconds": 12.0,
-   "avg_fps": 3303.535,
-   "low_1pct_fps": 1248.887,
-   "low_01pct_fps": 802.528,
-   "p50_ms": 0.28,
-   "p95_ms": 0.413,
-   "p99_ms": 0.642,
-   "p999_ms": 1.087,
-   "max_ms": 2.215,
-   "cpu_p50_ms": 0.158,
-   "gpu_p50_ms": 0.069,
-   "histogram": [
-    39582,
-    60,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 40436,
-   "seconds": 12.0,
-   "avg_fps": 3369.626,
-   "low_1pct_fps": 1369.962,
-   "low_01pct_fps": 790.305,
-   "p50_ms": 0.279,
-   "p95_ms": 0.403,
-   "p99_ms": 0.604,
-   "p999_ms": 0.812,
-   "max_ms": 10.313,
-   "cpu_p50_ms": 0.159,
-   "gpu_p50_ms": 0.069,
-   "histogram": [
-    40425,
-    8,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 40860,
-   "seconds": 12.0,
-   "avg_fps": 3404.933,
-   "low_1pct_fps": 1457.203,
-   "low_01pct_fps": 969.318,
-   "p50_ms": 0.278,
-   "p95_ms": 0.389,
-   "p99_ms": 0.574,
-   "p999_ms": 0.814,
-   "max_ms": 2.714,
-   "cpu_p50_ms": 0.158,
-   "gpu_p50_ms": 0.069,
-   "histogram": [
-    40847,
-    11,
-    2,
-    0,
-    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": 40229,
-   "seconds": 12.0,
-   "avg_fps": 3352.309,
-   "low_1pct_fps": 1324.071,
-   "low_01pct_fps": 791.016,
-   "p50_ms": 0.28,
-   "p95_ms": 0.402,
-   "p99_ms": 0.617,
-   "p999_ms": 0.968,
-   "max_ms": 3.746,
-   "cpu_p50_ms": 0.159,
-   "gpu_p50_ms": 0.069,
-   "histogram": [
-    40192,
-    35,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  }
- ],
- "label": "horizon-win-9800x3d-5080"
-}

benchmarks/perf/vanilla-mods-win-9800x3d-5080-rd16.json

@@ -1,706 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-10-29T01:25:53Z",
- "app": {
-  "name": "minecraft",
-  "version": "26.3",
-  "mods": [
-   {
-    "name": "fabric-loader",
-    "version": "0.19.5"
-   },
-   {
-    "name": "sodium",
-    "version": "mc26.3-0.9.2-fabric"
-   },
-   {
-    "name": "lithium",
-    "version": "mc26.3-0.26.2-fabric"
-   },
-   {
-    "name": "ferrite-core",
-    "version": "9.0.0-fabric"
-   },
-   {
-    "name": "immediatelyfast",
-    "version": "1.17.1+26.3-fabric"
-   }
-  ]
- },
- "hardware": {
-  "os": "windows",
-  "arch": "x86_64",
-  "cpu_threads": 16,
-  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
-  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
-  "ram_mb": 95943,
-  "gpu": {
-   "name": "NVIDIA GeForce RTX 5080/PCIe/SSE2",
-   "vendor": "NVIDIA Corporation",
-   "driver": "3.3.0 NVIDIA 617.42",
-   "backend": "opengl",
-   "kind": ""
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 16,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": false,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 10777.756,
-   "stdev": 129.67,
-   "min": 10636.92,
-   "max": 10892.2,
-   "ci95": 322.144
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 23477.423,
-   "stdev": 346.614,
-   "min": 23130.92,
-   "max": 23824.148,
-   "ci95": 861.106
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 6007.033,
-   "stdev": 104.227,
-   "min": 5891.431,
-   "max": 6093.825,
-   "ci95": 258.936
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 1282.11,
-   "stdev": 65.207,
-   "min": 1228.13,
-   "max": 1354.56,
-   "ci95": 161.997
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 343.465,
-   "stdev": 9.96,
-   "min": 335.223,
-   "max": 354.532,
-   "ci95": 24.744
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 131.669,
-   "stdev": 4.692,
-   "min": 126.427,
-   "max": 135.476,
-   "ci95": 11.656
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 8669.311,
-   "stdev": 434.39,
-   "min": 8280.854,
-   "max": 9138.35,
-   "ci95": 1079.173
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 1745.757,
-   "stdev": 13.014,
-   "min": 1734.41,
-   "max": 1759.963,
-   "ci95": 32.332
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 460.958,
-   "stdev": 10.859,
-   "min": 449.051,
-   "max": 470.316,
-   "ci95": 26.978
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 178.955,
-   "stdev": 3.777,
-   "min": 175.213,
-   "max": 182.766,
-   "ci95": 9.383
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 7056.368,
-   "stdev": 117.329,
-   "min": 6986.912,
-   "max": 7191.833,
-   "ci95": 291.485
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 1815.056,
-   "stdev": 47.875,
-   "min": 1759.788,
-   "max": 1843.745,
-   "ci95": 118.937
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 514.215,
-   "stdev": 57.205,
-   "min": 452.445,
-   "max": 565.368,
-   "ci95": 142.117
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 191.842,
-   "stdev": 23.217,
-   "min": 175.546,
-   "max": 218.426,
-   "ci95": 57.68
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 14094.582,
-   "stdev": 399.624,
-   "min": 13641.534,
-   "max": 14397.0,
-   "ci95": 992.801
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 1499.768,
-   "stdev": 22.197,
-   "min": 1477.269,
-   "max": 1521.651,
-   "ci95": 55.146
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 408.466,
-   "stdev": 16.114,
-   "min": 395.097,
-   "max": 426.358,
-   "ci95": 40.032
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 139.743,
-   "stdev": 3.969,
-   "min": 136.465,
-   "max": 144.156,
-   "ci95": 9.86
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 2495.607,
-   "stdev": 75.339,
-   "min": 2412.738,
-   "max": 2559.965,
-   "ci95": 187.166
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 2326.611,
-   "stdev": 15.702,
-   "min": 2314.98,
-   "max": 2344.473,
-   "ci95": 39.01
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 14738,
-   "seconds": 12.0,
-   "avg_fps": 1228.13,
-   "low_1pct_fps": 335.223,
-   "low_01pct_fps": 133.103,
-   "p50_ms": 0.722,
-   "p95_ms": 1.384,
-   "p99_ms": 2.043,
-   "p999_ms": 5.224,
-   "max_ms": 11.459,
-   "histogram": [
-    12159,
-    2421,
-    128,
-    14,
-    1,
-    5,
-    2,
-    3,
-    4,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 16255,
-   "seconds": 12.0,
-   "avg_fps": 1354.56,
-   "low_1pct_fps": 354.532,
-   "low_01pct_fps": 135.476,
-   "p50_ms": 0.672,
-   "p95_ms": 1.136,
-   "p99_ms": 1.841,
-   "p999_ms": 4.913,
-   "max_ms": 16.94,
-   "histogram": [
-    14841,
-    1298,
-    86,
-    13,
-    2,
-    5,
-    4,
-    1,
-    3,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 15164,
-   "seconds": 12.0,
-   "avg_fps": 1263.64,
-   "low_1pct_fps": 340.639,
-   "low_01pct_fps": 126.427,
-   "p50_ms": 0.708,
-   "p95_ms": 1.299,
-   "p99_ms": 1.895,
-   "p999_ms": 5.173,
-   "max_ms": 16.748,
-   "histogram": [
-    13026,
-    2014,
-    94,
-    13,
-    1,
-    3,
-    3,
-    6,
-    2,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 20915,
-   "seconds": 12.0,
-   "avg_fps": 1742.897,
-   "low_1pct_fps": 470.316,
-   "low_01pct_fps": 182.766,
-   "p50_ms": 0.5,
-   "p95_ms": 0.936,
-   "p99_ms": 1.437,
-   "p999_ms": 2.77,
-   "max_ms": 13.414,
-   "histogram": [
-    20067,
-    788,
-    44,
-    4,
-    0,
-    4,
-    3,
-    3,
-    1,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 21120,
-   "seconds": 12.0,
-   "avg_fps": 1759.963,
-   "low_1pct_fps": 449.051,
-   "low_01pct_fps": 178.887,
-   "p50_ms": 0.49,
-   "p95_ms": 0.901,
-   "p99_ms": 1.531,
-   "p999_ms": 3.005,
-   "max_ms": 12.907,
-   "histogram": [
-    20414,
-    644,
-    40,
-    10,
-    1,
-    3,
-    2,
-    2,
-    2,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 20813,
-   "seconds": 12.0,
-   "avg_fps": 1734.41,
-   "low_1pct_fps": 463.506,
-   "low_01pct_fps": 175.213,
-   "p50_ms": 0.496,
-   "p95_ms": 0.924,
-   "p99_ms": 1.414,
-   "p999_ms": 2.733,
-   "max_ms": 16.832,
-   "histogram": [
-    20049,
-    707,
-    41,
-    5,
-    0,
-    1,
-    5,
-    2,
-    2,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 22100,
-   "seconds": 12.0,
-   "avg_fps": 1841.634,
-   "low_1pct_fps": 565.368,
-   "low_01pct_fps": 218.426,
-   "p50_ms": 0.483,
-   "p95_ms": 0.835,
-   "p99_ms": 1.209,
-   "p999_ms": 2.082,
-   "max_ms": 14.627,
-   "histogram": [
-    21540,
-    532,
-    18,
-    1,
-    1,
-    1,
-    2,
-    2,
-    1,
-    1,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 21118,
-   "seconds": 12.0,
-   "avg_fps": 1759.788,
-   "low_1pct_fps": 452.445,
-   "low_01pct_fps": 175.546,
-   "p50_ms": 0.489,
-   "p95_ms": 0.915,
-   "p99_ms": 1.532,
-   "p999_ms": 2.811,
-   "max_ms": 11.846,
-   "histogram": [
-    20308,
-    755,
-    36,
-    9,
-    0,
-    2,
-    0,
-    3,
-    2,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 22125,
-   "seconds": 12.0,
-   "avg_fps": 1843.745,
-   "low_1pct_fps": 524.832,
-   "low_01pct_fps": 181.555,
-   "p50_ms": 0.477,
-   "p95_ms": 0.855,
-   "p99_ms": 1.241,
-   "p999_ms": 2.236,
-   "max_ms": 12.478,
-   "histogram": [
-    21487,
-    608,
-    18,
-    1,
-    1,
-    1,
-    2,
-    2,
-    1,
-    2,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 18005,
-   "seconds": 12.0,
-   "avg_fps": 1500.383,
-   "low_1pct_fps": 403.944,
-   "low_01pct_fps": 136.465,
-   "p50_ms": 0.591,
-   "p95_ms": 1.058,
-   "p99_ms": 1.592,
-   "p999_ms": 3.186,
-   "max_ms": 12.608,
-   "histogram": [
-    16864,
-    1084,
-    32,
-    8,
-    0,
-    5,
-    3,
-    5,
-    1,
-    2,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 17728,
-   "seconds": 12.001,
-   "avg_fps": 1477.269,
-   "low_1pct_fps": 395.097,
-   "low_01pct_fps": 138.609,
-   "p50_ms": 0.598,
-   "p95_ms": 1.042,
-   "p99_ms": 1.561,
-   "p999_ms": 5.033,
-   "max_ms": 11.462,
-   "histogram": [
-    16612,
-    1051,
-    39,
-    7,
-    1,
-    6,
-    5,
-    3,
-    1,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 18260,
-   "seconds": 12.0,
-   "avg_fps": 1521.651,
-   "low_1pct_fps": 426.358,
-   "low_01pct_fps": 144.156,
-   "p50_ms": 0.585,
-   "p95_ms": 1.015,
-   "p99_ms": 1.458,
-   "p999_ms": 3.609,
-   "max_ms": 11.945,
-   "histogram": [
-    17267,
-    943,
-    26,
-    6,
-    5,
-    2,
-    3,
-    3,
-    2,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  }
- ],
- "label": "vanilla-mods-win-9800x3d-5080"
-}

benchmarks/perf/vanilla-mods-win-9800x3d-5080-rd32.json

@@ -1,706 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-10-29T19:27:56Z",
- "app": {
-  "name": "minecraft",
-  "version": "26.3",
-  "mods": [
-   {
-    "name": "fabric-loader",
-    "version": "0.19.5"
-   },
-   {
-    "name": "sodium",
-    "version": "mc26.3-0.9.2-fabric"
-   },
-   {
-    "name": "lithium",
-    "version": "mc26.3-0.26.2-fabric"
-   },
-   {
-    "name": "ferrite-core",
-    "version": "9.0.0-fabric"
-   },
-   {
-    "name": "immediatelyfast",
-    "version": "1.17.1+26.3-fabric"
-   }
-  ]
- },
- "hardware": {
-  "os": "windows",
-  "arch": "x86_64",
-  "cpu_threads": 16,
-  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
-  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
-  "ram_mb": 95943,
-  "gpu": {
-   "name": "NVIDIA GeForce RTX 5080/PCIe/SSE2",
-   "vendor": "NVIDIA Corporation",
-   "driver": "3.3.0 NVIDIA 617.42",
-   "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,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 11038.922,
-   "stdev": 118.058,
-   "min": 10935.424,
-   "max": 11167.506,
-   "ci95": 293.295
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 39248.588,
-   "stdev": 479.755,
-   "min": 38964.834,
-   "max": 39802.506,
-   "ci95": 1191.875
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 11176.953,
-   "stdev": 356.144,
-   "min": 10836.65,
-   "max": 11547.064,
-   "ci95": 884.781
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 925.977,
-   "stdev": 6.727,
-   "min": 918.832,
-   "max": 932.189,
-   "ci95": 16.713
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 250.092,
-   "stdev": 1.868,
-   "min": 248.431,
-   "max": 252.114,
-   "ci95": 4.64
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 92.692,
-   "stdev": 4.466,
-   "min": 88.423,
-   "max": 97.332,
-   "ci95": 11.095
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 17335.638,
-   "stdev": 687.588,
-   "min": 16544.168,
-   "max": 17785.772,
-   "ci95": 1708.201
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 929.034,
-   "stdev": 3.11,
-   "min": 926.32,
-   "max": 932.428,
-   "ci95": 7.727
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 312.69,
-   "stdev": 16.386,
-   "min": 297.667,
-   "max": 330.163,
-   "ci95": 40.708
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 129.331,
-   "stdev": 12.786,
-   "min": 115.486,
-   "max": 140.694,
-   "ci95": 31.765
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 12601.063,
-   "stdev": 148.042,
-   "min": 12430.182,
-   "max": 12690.506,
-   "ci95": 367.785
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 1016.598,
-   "stdev": 5.481,
-   "min": 1010.482,
-   "max": 1021.068,
-   "ci95": 13.618
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 325.361,
-   "stdev": 15.112,
-   "min": 315.682,
-   "max": 342.774,
-   "ci95": 37.543
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 117.042,
-   "stdev": 11.095,
-   "min": 107.807,
-   "max": 129.349,
-   "ci95": 27.563
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 38513.008,
-   "stdev": 958.119,
-   "min": 37447.333,
-   "max": 39303.226,
-   "ci95": 2380.292
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 644.782,
-   "stdev": 3.94,
-   "min": 640.866,
-   "max": 648.745,
-   "ci95": 9.788
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 166.029,
-   "stdev": 4.758,
-   "min": 162.326,
-   "max": 171.395,
-   "ci95": 11.819
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 86.231,
-   "stdev": 8.587,
-   "min": 76.632,
-   "max": 93.184,
-   "ci95": 21.334
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 2964.911,
-   "stdev": 8.27,
-   "min": 2959.813,
-   "max": 2974.453,
-   "ci95": 20.545
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 2894.541,
-   "stdev": 12.847,
-   "min": 2879.928,
-   "max": 2904.059,
-   "ci95": 31.917
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 11123,
-   "seconds": 12.0,
-   "avg_fps": 926.911,
-   "low_1pct_fps": 249.732,
-   "low_01pct_fps": 92.322,
-   "p50_ms": 0.989,
-   "p95_ms": 1.492,
-   "p99_ms": 2.33,
-   "p999_ms": 7.409,
-   "max_ms": 15.258,
-   "histogram": [
-    6224,
-    4701,
-    147,
-    28,
-    3,
-    2,
-    5,
-    3,
-    3,
-    3,
-    1,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 11187,
-   "seconds": 12.001,
-   "avg_fps": 932.189,
-   "low_1pct_fps": 252.114,
-   "low_01pct_fps": 88.423,
-   "p50_ms": 0.984,
-   "p95_ms": 1.496,
-   "p99_ms": 2.328,
-   "p999_ms": 7.858,
-   "max_ms": 16.843,
-   "histogram": [
-    6518,
-    4486,
-    138,
-    20,
-    9,
-    1,
-    1,
-    6,
-    1,
-    2,
-    3,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 11026,
-   "seconds": 12.0,
-   "avg_fps": 918.832,
-   "low_1pct_fps": 248.431,
-   "low_01pct_fps": 97.332,
-   "p50_ms": 0.989,
-   "p95_ms": 1.524,
-   "p99_ms": 2.37,
-   "p999_ms": 7.446,
-   "max_ms": 16.573,
-   "histogram": [
-    6075,
-    4740,
-    162,
-    23,
-    5,
-    2,
-    4,
-    7,
-    4,
-    1,
-    1,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 11117,
-   "seconds": 12.001,
-   "avg_fps": 926.32,
-   "low_1pct_fps": 310.239,
-   "low_01pct_fps": 131.814,
-   "p50_ms": 1.011,
-   "p95_ms": 1.34,
-   "p99_ms": 2.045,
-   "p999_ms": 4.711,
-   "max_ms": 14.077,
-   "histogram": [
-    3849,
-    7150,
-    78,
-    26,
-    5,
-    1,
-    3,
-    2,
-    1,
-    0,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 11190,
-   "seconds": 12.001,
-   "avg_fps": 932.428,
-   "low_1pct_fps": 330.163,
-   "low_01pct_fps": 140.694,
-   "p50_ms": 1.008,
-   "p95_ms": 1.307,
-   "p99_ms": 1.869,
-   "p999_ms": 4.341,
-   "max_ms": 13.489,
-   "histogram": [
-    4273,
-    6822,
-    60,
-    20,
-    7,
-    0,
-    3,
-    3,
-    0,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 11141,
-   "seconds": 12.001,
-   "avg_fps": 928.354,
-   "low_1pct_fps": 297.667,
-   "low_01pct_fps": 115.486,
-   "p50_ms": 1.005,
-   "p95_ms": 1.352,
-   "p99_ms": 2.054,
-   "p999_ms": 5.292,
-   "max_ms": 14.339,
-   "histogram": [
-    4901,
-    6118,
-    83,
-    23,
-    3,
-    2,
-    4,
-    3,
-    0,
-    1,
-    2,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 12126,
-   "seconds": 12.0,
-   "avg_fps": 1010.482,
-   "low_1pct_fps": 317.626,
-   "low_01pct_fps": 113.971,
-   "p50_ms": 0.933,
-   "p95_ms": 1.23,
-   "p99_ms": 1.935,
-   "p999_ms": 4.393,
-   "max_ms": 14.824,
-   "histogram": [
-    9183,
-    2830,
-    82,
-    17,
-    3,
-    1,
-    2,
-    3,
-    0,
-    1,
-    3,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 12219,
-   "seconds": 12.0,
-   "avg_fps": 1018.243,
-   "low_1pct_fps": 342.774,
-   "low_01pct_fps": 129.349,
-   "p50_ms": 0.929,
-   "p95_ms": 1.222,
-   "p99_ms": 1.867,
-   "p999_ms": 4.329,
-   "max_ms": 10.33,
-   "histogram": [
-    9421,
-    2710,
-    60,
-    15,
-    3,
-    0,
-    0,
-    5,
-    3,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 12253,
-   "seconds": 12.0,
-   "avg_fps": 1021.068,
-   "low_1pct_fps": 315.682,
-   "low_01pct_fps": 107.807,
-   "p50_ms": 0.923,
-   "p95_ms": 1.225,
-   "p99_ms": 1.969,
-   "p999_ms": 5.235,
-   "max_ms": 19.524,
-   "histogram": [
-    9231,
-    2904,
-    92,
-    10,
-    2,
-    5,
-    0,
-    4,
-    1,
-    2,
-    0,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 7691,
-   "seconds": 12.001,
-   "avg_fps": 640.866,
-   "low_1pct_fps": 164.367,
-   "low_01pct_fps": 93.184,
-   "p50_ms": 1.454,
-   "p95_ms": 1.95,
-   "p99_ms": 3.4,
-   "p999_ms": 9.754,
-   "max_ms": 14.995,
-   "histogram": [
-    36,
-    7331,
-    233,
-    26,
-    17,
-    13,
-    20,
-    3,
-    6,
-    5,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 7737,
-   "seconds": 12.0,
-   "avg_fps": 644.736,
-   "low_1pct_fps": 162.326,
-   "low_01pct_fps": 76.632,
-   "p50_ms": 1.454,
-   "p95_ms": 1.905,
-   "p99_ms": 3.676,
-   "p999_ms": 9.926,
-   "max_ms": 18.459,
-   "histogram": [
-    46,
-    7399,
-    199,
-    24,
-    21,
-    24,
-    10,
-    6,
-    1,
-    1,
-    4,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 7785,
-   "seconds": 12.0,
-   "avg_fps": 648.745,
-   "low_1pct_fps": 171.395,
-   "low_01pct_fps": 88.876,
-   "p50_ms": 1.439,
-   "p95_ms": 1.886,
-   "p99_ms": 3.562,
-   "p999_ms": 10.342,
-   "max_ms": 12.927,
-   "histogram": [
-    57,
-    7432,
-    186,
-    44,
-    23,
-    20,
-    9,
-    3,
-    3,
-    7,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  }
- ],
- "label": "vanilla-mods-win-9800x3d-5080"
-}

benchmarks/perf/vanilla-mods-win-9800x3d-5080-rd8.json

@@ -1,706 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-10-29T18:49:40Z",
- "app": {
-  "name": "minecraft",
-  "version": "26.3",
-  "mods": [
-   {
-    "name": "fabric-loader",
-    "version": "0.19.5"
-   },
-   {
-    "name": "sodium",
-    "version": "mc26.3-0.9.2-fabric"
-   },
-   {
-    "name": "lithium",
-    "version": "mc26.3-0.26.2-fabric"
-   },
-   {
-    "name": "ferrite-core",
-    "version": "9.0.0-fabric"
-   },
-   {
-    "name": "immediatelyfast",
-    "version": "1.17.1+26.3-fabric"
-   }
-  ]
- },
- "hardware": {
-  "os": "windows",
-  "arch": "x86_64",
-  "cpu_threads": 16,
-  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
-  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
-  "ram_mb": 95943,
-  "gpu": {
-   "name": "NVIDIA GeForce RTX 5080/PCIe/SSE2",
-   "vendor": "NVIDIA Corporation",
-   "driver": "3.3.0 NVIDIA 617.42",
-   "backend": "opengl",
-   "kind": ""
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 8,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": false,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 11089.831,
-   "stdev": 46.336,
-   "min": 11036.36,
-   "max": 11118.192,
-   "ci95": 115.114
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 17643.831,
-   "stdev": 47.672,
-   "min": 17589.192,
-   "max": 17676.942,
-   "ci95": 118.433
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 3603.773,
-   "stdev": 161.342,
-   "min": 3488.106,
-   "max": 3788.086,
-   "ci95": 400.828
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 2103.54,
-   "stdev": 40.465,
-   "min": 2078.464,
-   "max": 2150.222,
-   "ci95": 100.529
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 577.326,
-   "stdev": 33.693,
-   "min": 557.613,
-   "max": 616.23,
-   "ci95": 83.704
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 195.53,
-   "stdev": 18.899,
-   "min": 181.495,
-   "max": 217.019,
-   "ci95": 46.951
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 3282.612,
-   "stdev": 48.569,
-   "min": 3233.16,
-   "max": 3330.246,
-   "ci95": 120.661
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 2424.739,
-   "stdev": 26.074,
-   "min": 2394.789,
-   "max": 2442.383,
-   "ci95": 64.777
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 732.987,
-   "stdev": 11.926,
-   "min": 724.144,
-   "max": 746.55,
-   "ci95": 29.627
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 249.926,
-   "stdev": 8.826,
-   "min": 241.293,
-   "max": 258.934,
-   "ci95": 21.928
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 2705.954,
-   "stdev": 173.487,
-   "min": 2538.486,
-   "max": 2884.891,
-   "ci95": 431.0
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 2431.99,
-   "stdev": 33.071,
-   "min": 2394.02,
-   "max": 2454.493,
-   "ci95": 82.159
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 764.065,
-   "stdev": 14.782,
-   "min": 747.287,
-   "max": 775.168,
-   "ci95": 36.723
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 261.954,
-   "stdev": 14.724,
-   "min": 252.457,
-   "max": 278.916,
-   "ci95": 36.58
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 4982.865,
-   "stdev": 115.523,
-   "min": 4849.837,
-   "max": 5057.932,
-   "ci95": 286.997
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 2538.05,
-   "stdev": 67.405,
-   "min": 2462.815,
-   "max": 2592.938,
-   "ci95": 167.458
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 760.16,
-   "stdev": 13.503,
-   "min": 746.001,
-   "max": 772.895,
-   "ci95": 33.547
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 240.897,
-   "stdev": 17.872,
-   "min": 224.391,
-   "max": 259.878,
-   "ci95": 44.401
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 2052.982,
-   "stdev": 57.756,
-   "min": 1992.574,
-   "max": 2107.66,
-   "ci95": 143.487
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 1903.921,
-   "stdev": 62.254,
-   "min": 1838.307,
-   "max": 1962.156,
-   "ci95": 154.659
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 25803,
-   "seconds": 12.0,
-   "avg_fps": 2150.222,
-   "low_1pct_fps": 616.23,
-   "low_01pct_fps": 217.019,
-   "p50_ms": 0.433,
-   "p95_ms": 0.642,
-   "p99_ms": 1.04,
-   "p999_ms": 2.307,
-   "max_ms": 7.466,
-   "histogram": [
-    25503,
-    269,
-    8,
-    6,
-    7,
-    6,
-    2,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 24942,
-   "seconds": 12.0,
-   "avg_fps": 2078.464,
-   "low_1pct_fps": 557.613,
-   "low_01pct_fps": 181.495,
-   "p50_ms": 0.45,
-   "p95_ms": 0.665,
-   "p99_ms": 1.1,
-   "p999_ms": 2.305,
-   "max_ms": 9.819,
-   "histogram": [
-    24615,
-    288,
-    17,
-    2,
-    4,
-    9,
-    2,
-    3,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 24984,
-   "seconds": 12.0,
-   "avg_fps": 2081.934,
-   "low_1pct_fps": 558.135,
-   "low_01pct_fps": 188.076,
-   "p50_ms": 0.444,
-   "p95_ms": 0.682,
-   "p99_ms": 1.101,
-   "p999_ms": 2.412,
-   "max_ms": 11.567,
-   "histogram": [
-    24645,
-    308,
-    9,
-    3,
-    5,
-    5,
-    7,
-    1,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 29245,
-   "seconds": 12.0,
-   "avg_fps": 2437.044,
-   "low_1pct_fps": 728.266,
-   "low_01pct_fps": 249.55,
-   "p50_ms": 0.38,
-   "p95_ms": 0.555,
-   "p99_ms": 0.892,
-   "p999_ms": 1.851,
-   "max_ms": 6.973,
-   "histogram": [
-    29066,
-    154,
-    4,
-    6,
-    7,
-    6,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 28738,
-   "seconds": 12.0,
-   "avg_fps": 2394.789,
-   "low_1pct_fps": 724.144,
-   "low_01pct_fps": 241.293,
-   "p50_ms": 0.384,
-   "p95_ms": 0.571,
-   "p99_ms": 0.907,
-   "p999_ms": 1.833,
-   "max_ms": 8.35,
-   "histogram": [
-    28573,
-    140,
-    6,
-    3,
-    6,
-    5,
-    3,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 29309,
-   "seconds": 12.0,
-   "avg_fps": 2442.383,
-   "low_1pct_fps": 746.55,
-   "low_01pct_fps": 258.934,
-   "p50_ms": 0.378,
-   "p95_ms": 0.566,
-   "p99_ms": 0.876,
-   "p999_ms": 1.744,
-   "max_ms": 10.291,
-   "histogram": [
-    29138,
-    148,
-    5,
-    6,
-    5,
-    2,
-    4,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 29454,
-   "seconds": 12.0,
-   "avg_fps": 2454.493,
-   "low_1pct_fps": 769.741,
-   "low_01pct_fps": 252.457,
-   "p50_ms": 0.378,
-   "p95_ms": 0.55,
-   "p99_ms": 0.853,
-   "p999_ms": 1.471,
-   "max_ms": 6.629,
-   "histogram": [
-    29323,
-    110,
-    2,
-    2,
-    7,
-    7,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 28729,
-   "seconds": 12.0,
-   "avg_fps": 2394.02,
-   "low_1pct_fps": 747.287,
-   "low_01pct_fps": 254.49,
-   "p50_ms": 0.383,
-   "p95_ms": 0.579,
-   "p99_ms": 0.896,
-   "p999_ms": 1.56,
-   "max_ms": 7.367,
-   "histogram": [
-    28567,
-    141,
-    3,
-    5,
-    4,
-    4,
-    4,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 29370,
-   "seconds": 12.0,
-   "avg_fps": 2447.458,
-   "low_1pct_fps": 775.168,
-   "low_01pct_fps": 278.916,
-   "p50_ms": 0.376,
-   "p95_ms": 0.559,
-   "p99_ms": 0.887,
-   "p999_ms": 1.567,
-   "max_ms": 9.65,
-   "histogram": [
-    29209,
-    141,
-    3,
-    9,
-    0,
-    5,
-    1,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 31116,
-   "seconds": 12.0,
-   "avg_fps": 2592.938,
-   "low_1pct_fps": 761.584,
-   "low_01pct_fps": 224.391,
-   "p50_ms": 0.356,
-   "p95_ms": 0.511,
-   "p99_ms": 0.767,
-   "p999_ms": 1.843,
-   "max_ms": 8.478,
-   "histogram": [
-    31011,
-    76,
-    4,
-    3,
-    13,
-    4,
-    3,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 29554,
-   "seconds": 12.0,
-   "avg_fps": 2462.815,
-   "low_1pct_fps": 746.001,
-   "low_01pct_fps": 238.423,
-   "p50_ms": 0.366,
-   "p95_ms": 0.579,
-   "p99_ms": 0.849,
-   "p999_ms": 1.75,
-   "max_ms": 7.607,
-   "histogram": [
-    29430,
-    101,
-    2,
-    3,
-    9,
-    4,
-    3,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 30701,
-   "seconds": 12.0,
-   "avg_fps": 2558.396,
-   "low_1pct_fps": 772.895,
-   "low_01pct_fps": 259.878,
-   "p50_ms": 0.357,
-   "p95_ms": 0.537,
-   "p99_ms": 0.81,
-   "p999_ms": 1.702,
-   "max_ms": 6.682,
-   "histogram": [
-    30568,
-    112,
-    1,
-    6,
-    5,
-    3,
-    6,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  }
- ],
- "label": "vanilla-mods-win-9800x3d-5080"
-}

benchmarks/perf/vanilla-win-9800x3d-5080-rd16.json

@@ -1,690 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-10-29T01:19:23Z",
- "app": {
-  "name": "minecraft",
-  "version": "26.3",
-  "mods": [
-   {
-    "name": "fabric-loader",
-    "version": "0.19.5"
-   }
-  ]
- },
- "hardware": {
-  "os": "windows",
-  "arch": "x86_64",
-  "cpu_threads": 16,
-  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
-  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
-  "ram_mb": 95943,
-  "gpu": {
-   "name": "NVIDIA GeForce RTX 5080/PCIe/SSE2",
-   "vendor": "NVIDIA Corporation",
-   "driver": "3.3.0 NVIDIA 617.42",
-   "backend": "opengl",
-   "kind": ""
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 16,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": false,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 7681.834,
-   "stdev": 189.48,
-   "min": 7538.777,
-   "max": 7896.728,
-   "ci95": 470.732
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 19898.834,
-   "stdev": 192.981,
-   "min": 19695.728,
-   "max": 20079.777,
-   "ci95": 479.431
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 6127.947,
-   "stdev": 26.756,
-   "min": 6097.19,
-   "max": 6145.854,
-   "ci95": 66.471
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 1218.486,
-   "stdev": 26.337,
-   "min": 1188.13,
-   "max": 1235.248,
-   "ci95": 65.43
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 318.468,
-   "stdev": 6.292,
-   "min": 313.2,
-   "max": 325.435,
-   "ci95": 15.632
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 126.59,
-   "stdev": 1.844,
-   "min": 124.744,
-   "max": 128.431,
-   "ci95": 4.58
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 8548.814,
-   "stdev": 152.302,
-   "min": 8380.912,
-   "max": 8678.071,
-   "ci95": 378.37
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 1912.359,
-   "stdev": 130.238,
-   "min": 1791.386,
-   "max": 2050.215,
-   "ci95": 323.555
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 401.907,
-   "stdev": 35.911,
-   "min": 379.849,
-   "max": 443.345,
-   "ci95": 89.216
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 149.26,
-   "stdev": 9.983,
-   "min": 139.809,
-   "max": 159.701,
-   "ci95": 24.801
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 6953.478,
-   "stdev": 276.636,
-   "min": 6635.649,
-   "max": 7140.072,
-   "ci95": 687.258
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 1860.512,
-   "stdev": 116.512,
-   "min": 1726.149,
-   "max": 1933.597,
-   "ci95": 289.454
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 446.336,
-   "stdev": 56.993,
-   "min": 382.26,
-   "max": 491.369,
-   "ci95": 141.589
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 164.934,
-   "stdev": 11.839,
-   "min": 152.493,
-   "max": 176.062,
-   "ci95": 29.413
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 15211.386,
-   "stdev": 256.348,
-   "min": 14938.008,
-   "max": 15446.375,
-   "ci95": 636.856
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 1653.223,
-   "stdev": 61.705,
-   "min": 1584.652,
-   "max": 1704.273,
-   "ci95": 153.297
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 331.929,
-   "stdev": 10.858,
-   "min": 319.394,
-   "max": 338.396,
-   "ci95": 26.974
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 113.436,
-   "stdev": 3.255,
-   "min": 110.869,
-   "max": 117.097,
-   "ci95": 8.086
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 2540.129,
-   "stdev": 152.057,
-   "min": 2373.152,
-   "max": 2670.633,
-   "ci95": 377.761
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 2299.514,
-   "stdev": 81.451,
-   "min": 2207.129,
-   "max": 2360.973,
-   "ci95": 202.352
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 14785,
-   "seconds": 12.0,
-   "avg_fps": 1232.081,
-   "low_1pct_fps": 325.435,
-   "low_01pct_fps": 128.431,
-   "p50_ms": 0.742,
-   "p95_ms": 1.265,
-   "p99_ms": 2.032,
-   "p999_ms": 5.653,
-   "max_ms": 12.791,
-   "histogram": [
-    12845,
-    1784,
-    127,
-    7,
-    1,
-    8,
-    4,
-    3,
-    5,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 14258,
-   "seconds": 12.0,
-   "avg_fps": 1188.13,
-   "low_1pct_fps": 313.2,
-   "low_01pct_fps": 126.595,
-   "p50_ms": 0.757,
-   "p95_ms": 1.349,
-   "p99_ms": 2.12,
-   "p999_ms": 5.541,
-   "max_ms": 13.998,
-   "histogram": [
-    11994,
-    2076,
-    157,
-    9,
-    2,
-    8,
-    2,
-    4,
-    5,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 14823,
-   "seconds": 12.0,
-   "avg_fps": 1235.248,
-   "low_1pct_fps": 316.768,
-   "low_01pct_fps": 124.744,
-   "p50_ms": 0.744,
-   "p95_ms": 1.199,
-   "p99_ms": 2.047,
-   "p999_ms": 5.628,
-   "max_ms": 15.519,
-   "histogram": [
-    13214,
-    1453,
-    118,
-    16,
-    2,
-    8,
-    6,
-    3,
-    0,
-    1,
-    0,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 21497,
-   "seconds": 12.0,
-   "avg_fps": 1791.386,
-   "low_1pct_fps": 382.527,
-   "low_01pct_fps": 139.809,
-   "p50_ms": 0.474,
-   "p95_ms": 0.931,
-   "p99_ms": 1.646,
-   "p999_ms": 5.274,
-   "max_ms": 13.459,
-   "histogram": [
-    20598,
-    799,
-    66,
-    9,
-    3,
-    8,
-    8,
-    2,
-    2,
-    0,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 24603,
-   "seconds": 12.0,
-   "avg_fps": 2050.215,
-   "low_1pct_fps": 443.345,
-   "low_01pct_fps": 159.701,
-   "p50_ms": 0.426,
-   "p95_ms": 0.752,
-   "p99_ms": 1.442,
-   "p999_ms": 3.134,
-   "max_ms": 13.282,
-   "histogram": [
-    24041,
-    487,
-    48,
-    6,
-    5,
-    6,
-    2,
-    3,
-    3,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 22746,
-   "seconds": 12.0,
-   "avg_fps": 1895.476,
-   "low_1pct_fps": 379.849,
-   "low_01pct_fps": 148.269,
-   "p50_ms": 0.456,
-   "p95_ms": 0.829,
-   "p99_ms": 1.561,
-   "p999_ms": 4.176,
-   "max_ms": 10.671,
-   "histogram": [
-    22092,
-    523,
-    91,
-    17,
-    4,
-    7,
-    3,
-    4,
-    4,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 23062,
-   "seconds": 12.0,
-   "avg_fps": 1921.791,
-   "low_1pct_fps": 465.379,
-   "low_01pct_fps": 166.247,
-   "p50_ms": 0.463,
-   "p95_ms": 0.809,
-   "p99_ms": 1.45,
-   "p999_ms": 2.398,
-   "max_ms": 11.808,
-   "histogram": [
-    22454,
-    561,
-    27,
-    3,
-    2,
-    6,
-    0,
-    4,
-    3,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 23204,
-   "seconds": 12.0,
-   "avg_fps": 1933.597,
-   "low_1pct_fps": 491.369,
-   "low_01pct_fps": 176.062,
-   "p50_ms": 0.466,
-   "p95_ms": 0.766,
-   "p99_ms": 1.406,
-   "p999_ms": 2.229,
-   "max_ms": 15.102,
-   "histogram": [
-    22699,
-    469,
-    19,
-    4,
-    1,
-    1,
-    4,
-    2,
-    2,
-    2,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 20714,
-   "seconds": 12.0,
-   "avg_fps": 1726.149,
-   "low_1pct_fps": 382.26,
-   "low_01pct_fps": 152.493,
-   "p50_ms": 0.5,
-   "p95_ms": 0.956,
-   "p99_ms": 1.742,
-   "p999_ms": 3.852,
-   "max_ms": 12.888,
-   "histogram": [
-    19814,
-    787,
-    83,
-    11,
-    2,
-    7,
-    3,
-    5,
-    0,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 20049,
-   "seconds": 12.0,
-   "avg_fps": 1670.745,
-   "low_1pct_fps": 338.396,
-   "low_01pct_fps": 117.097,
-   "p50_ms": 0.502,
-   "p95_ms": 0.949,
-   "p99_ms": 1.673,
-   "p999_ms": 6.456,
-   "max_ms": 16.791,
-   "histogram": [
-    19187,
-    753,
-    70,
-    8,
-    1,
-    6,
-    12,
-    4,
-    3,
-    4,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 19016,
-   "seconds": 12.0,
-   "avg_fps": 1584.652,
-   "low_1pct_fps": 337.998,
-   "low_01pct_fps": 112.343,
-   "p50_ms": 0.531,
-   "p95_ms": 1.082,
-   "p99_ms": 1.717,
-   "p999_ms": 5.939,
-   "max_ms": 12.958,
-   "histogram": [
-    17849,
-    1069,
-    63,
-    7,
-    3,
-    6,
-    2,
-    7,
-    4,
-    5,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 20452,
-   "seconds": 12.0,
-   "avg_fps": 1704.273,
-   "low_1pct_fps": 319.394,
-   "low_01pct_fps": 110.869,
-   "p50_ms": 0.496,
-   "p95_ms": 0.911,
-   "p99_ms": 1.706,
-   "p999_ms": 5.938,
-   "max_ms": 24.863,
-   "histogram": [
-    19694,
-    626,
-    82,
-    14,
-    3,
-    14,
-    5,
-    4,
-    5,
-    3,
-    1,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  }
- ],
- "label": "vanilla-win-9800x3d-5080"
-}

benchmarks/perf/vanilla-win-9800x3d-5080-rd32.json

@@ -1,690 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-10-29T19:06:49Z",
- "app": {
-  "name": "minecraft",
-  "version": "26.3",
-  "mods": [
-   {
-    "name": "fabric-loader",
-    "version": "0.19.5"
-   }
-  ]
- },
- "hardware": {
-  "os": "windows",
-  "arch": "x86_64",
-  "cpu_threads": 16,
-  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
-  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
-  "ram_mb": 95943,
-  "gpu": {
-   "name": "NVIDIA GeForce RTX 5080/PCIe/SSE2",
-   "vendor": "NVIDIA Corporation",
-   "driver": "3.3.0 NVIDIA 617.42",
-   "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,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 7518.874,
-   "stdev": 42.968,
-   "min": 7469.532,
-   "max": 7548.049,
-   "ci95": 106.748
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 35424.207,
-   "stdev": 144.711,
-   "min": 35318.049,
-   "max": 35589.041,
-   "ci95": 359.511
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 11146.828,
-   "stdev": 49.683,
-   "min": 11094.798,
-   "max": 11193.773,
-   "ci95": 123.43
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 882.053,
-   "stdev": 19.433,
-   "min": 866.126,
-   "max": 903.706,
-   "ci95": 48.279
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 183.995,
-   "stdev": 4.924,
-   "min": 178.512,
-   "max": 188.041,
-   "ci95": 12.234
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 83.193,
-   "stdev": 6.797,
-   "min": 77.734,
-   "max": 90.806,
-   "ci95": 16.886
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 18184.002,
-   "stdev": 266.879,
-   "min": 17880.667,
-   "max": 18382.735,
-   "ci95": 663.017
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 1202.907,
-   "stdev": 20.426,
-   "min": 1179.9,
-   "max": 1218.906,
-   "ci95": 50.744
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 228.139,
-   "stdev": 5.166,
-   "min": 222.394,
-   "max": 232.401,
-   "ci95": 12.833
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 107.956,
-   "stdev": 4.675,
-   "min": 105.185,
-   "max": 113.354,
-   "ci95": 11.614
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 13146.632,
-   "stdev": 507.943,
-   "min": 12572.118,
-   "max": 13536.145,
-   "ci95": 1261.902
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 1223.169,
-   "stdev": 13.11,
-   "min": 1208.837,
-   "max": 1234.556,
-   "ci95": 32.569
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 236.27,
-   "stdev": 6.77,
-   "min": 228.686,
-   "max": 241.702,
-   "ci95": 16.818
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 99.089,
-   "stdev": 8.354,
-   "min": 91.897,
-   "max": 108.253,
-   "ci95": 20.755
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 41846.641,
-   "stdev": 661.649,
-   "min": 41435.666,
-   "max": 42609.895,
-   "ci95": 1643.76
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 815.008,
-   "stdev": 24.644,
-   "min": 797.565,
-   "max": 843.201,
-   "ci95": 61.224
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 55.371,
-   "stdev": 5.128,
-   "min": 50.389,
-   "max": 60.633,
-   "ci95": 12.739
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 7.966,
-   "stdev": 1.103,
-   "min": 6.848,
-   "max": 9.053,
-   "ci95": 2.74
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 2892.492,
-   "stdev": 29.54,
-   "min": 2859.574,
-   "max": 2916.691,
-   "ci95": 73.387
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 2799.159,
-   "stdev": 12.256,
-   "min": 2786.234,
-   "max": 2810.613,
-   "ci95": 30.447
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 10845,
-   "seconds": 12.001,
-   "avg_fps": 903.706,
-   "low_1pct_fps": 185.432,
-   "low_01pct_fps": 81.039,
-   "p50_ms": 0.98,
-   "p95_ms": 1.708,
-   "p99_ms": 3.082,
-   "p999_ms": 9.304,
-   "max_ms": 15.487,
-   "histogram": [
-    6030,
-    4403,
-    297,
-    49,
-    25,
-    16,
-    8,
-    2,
-    6,
-    2,
-    4,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 10516,
-   "seconds": 12.0,
-   "avg_fps": 876.328,
-   "low_1pct_fps": 188.041,
-   "low_01pct_fps": 90.806,
-   "p50_ms": 1.012,
-   "p95_ms": 1.806,
-   "p99_ms": 3.354,
-   "p999_ms": 8.714,
-   "max_ms": 14.39,
-   "histogram": [
-    4927,
-    5158,
-    292,
-    70,
-    33,
-    13,
-    6,
-    5,
-    6,
-    2,
-    3,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 10394,
-   "seconds": 12.001,
-   "avg_fps": 866.126,
-   "low_1pct_fps": 178.512,
-   "low_01pct_fps": 77.734,
-   "p50_ms": 1.026,
-   "p95_ms": 1.789,
-   "p99_ms": 3.399,
-   "p999_ms": 10.6,
-   "max_ms": 15.389,
-   "histogram": [
-    4437,
-    5552,
-    273,
-    65,
-    18,
-    28,
-    8,
-    1,
-    1,
-    3,
-    5,
-    3,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 14519,
-   "seconds": 12.0,
-   "avg_fps": 1209.916,
-   "low_1pct_fps": 232.401,
-   "low_01pct_fps": 105.185,
-   "p50_ms": 0.726,
-   "p95_ms": 1.306,
-   "p99_ms": 2.25,
-   "p999_ms": 7.033,
-   "max_ms": 13.303,
-   "histogram": [
-    13121,
-    1197,
-    103,
-    36,
-    24,
-    19,
-    4,
-    3,
-    8,
-    2,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 14159,
-   "seconds": 12.0,
-   "avg_fps": 1179.9,
-   "low_1pct_fps": 222.394,
-   "low_01pct_fps": 105.33,
-   "p50_ms": 0.732,
-   "p95_ms": 1.366,
-   "p99_ms": 2.499,
-   "p999_ms": 8.061,
-   "max_ms": 11.797,
-   "histogram": [
-    12501,
-    1356,
-    195,
-    45,
-    25,
-    14,
-    6,
-    3,
-    9,
-    5,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 14627,
-   "seconds": 12.0,
-   "avg_fps": 1218.906,
-   "low_1pct_fps": 229.622,
-   "low_01pct_fps": 113.354,
-   "p50_ms": 0.713,
-   "p95_ms": 1.292,
-   "p99_ms": 2.317,
-   "p999_ms": 7.136,
-   "max_ms": 12.041,
-   "histogram": [
-    13194,
-    1224,
-    97,
-    47,
-    27,
-    21,
-    2,
-    6,
-    6,
-    2,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 14714,
-   "seconds": 12.001,
-   "avg_fps": 1226.113,
-   "low_1pct_fps": 238.423,
-   "low_01pct_fps": 97.117,
-   "p50_ms": 0.722,
-   "p95_ms": 1.223,
-   "p99_ms": 2.243,
-   "p999_ms": 7.032,
-   "max_ms": 13.21,
-   "histogram": [
-    13490,
-    1027,
-    115,
-    29,
-    18,
-    13,
-    7,
-    3,
-    3,
-    5,
-    4,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 14507,
-   "seconds": 12.001,
-   "avg_fps": 1208.837,
-   "low_1pct_fps": 228.686,
-   "low_01pct_fps": 91.897,
-   "p50_ms": 0.719,
-   "p95_ms": 1.256,
-   "p99_ms": 2.354,
-   "p999_ms": 7.473,
-   "max_ms": 15.432,
-   "histogram": [
-    13124,
-    1112,
-    180,
-    35,
-    23,
-    9,
-    8,
-    4,
-    2,
-    6,
-    2,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 14815,
-   "seconds": 12.0,
-   "avg_fps": 1234.556,
-   "low_1pct_fps": 241.702,
-   "low_01pct_fps": 108.253,
-   "p50_ms": 0.721,
-   "p95_ms": 1.2,
-   "p99_ms": 2.197,
-   "p999_ms": 6.689,
-   "max_ms": 12.791,
-   "histogram": [
-    13565,
-    1055,
-    107,
-    29,
-    23,
-    15,
-    8,
-    3,
-    4,
-    5,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 10119,
-   "seconds": 12.001,
-   "avg_fps": 843.201,
-   "low_1pct_fps": 60.633,
-   "low_01pct_fps": 9.053,
-   "p50_ms": 0.891,
-   "p95_ms": 1.845,
-   "p99_ms": 3.91,
-   "p999_ms": 8.209,
-   "max_ms": 316.409,
-   "histogram": [
-    6956,
-    2747,
-    240,
-    83,
-    45,
-    22,
-    8,
-    8,
-    5,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    4,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 9693,
-   "seconds": 12.052,
-   "avg_fps": 804.258,
-   "low_1pct_fps": 50.389,
-   "low_01pct_fps": 6.848,
-   "p50_ms": 0.906,
-   "p95_ms": 1.924,
-   "p99_ms": 4.157,
-   "p999_ms": 8.578,
-   "max_ms": 297.695,
-   "histogram": [
-    6578,
-    2678,
-    248,
-    94,
-    45,
-    18,
-    16,
-    5,
-    4,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    5,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 9571,
-   "seconds": 12.0,
-   "avg_fps": 797.565,
-   "low_1pct_fps": 55.09,
-   "low_01pct_fps": 7.997,
-   "p50_ms": 0.929,
-   "p95_ms": 1.944,
-   "p99_ms": 4.495,
-   "p999_ms": 7.764,
-   "max_ms": 321.994,
-   "histogram": [
-    5954,
-    3172,
-    230,
-    103,
-    39,
-    34,
-    19,
-    11,
-    4,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    4,
-    0,
-    0
-   ]
-  }
- ],
- "label": "vanilla-win-9800x3d-5080"
-}

benchmarks/perf/vanilla-win-9800x3d-5080-rd8.json

@@ -1,690 +0,0 @@
-{
- "format": "horizon-benchmark-report",
- "version": 1,
- "kind": "game",
- "created": "2026-10-29T18:43:17Z",
- "app": {
-  "name": "minecraft",
-  "version": "26.3",
-  "mods": [
-   {
-    "name": "fabric-loader",
-    "version": "0.19.5"
-   }
-  ]
- },
- "hardware": {
-  "os": "windows",
-  "arch": "x86_64",
-  "cpu_threads": 16,
-  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
-  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
-  "ram_mb": 95943,
-  "gpu": {
-   "name": "NVIDIA GeForce RTX 5080/PCIe/SSE2",
-   "vendor": "NVIDIA Corporation",
-   "driver": "3.3.0 NVIDIA 617.42",
-   "backend": "opengl",
-   "kind": ""
-  }
- },
- "conditions": {
-  "scenario": "perf_bench:village,forest,ocean,mountain",
-  "seed": "1234",
-  "render_distance": 8,
-  "simulation_distance": 12,
-  "vsync": false,
-  "offscreen": false,
-  "repeats": 3,
-  "warmup_s": 2.0,
-  "window": [
-   1280,
-   720
-  ]
- },
- "metrics": {
-  "startup.title_ms": {
-   "n": 3,
-   "mean": 7676.526,
-   "stdev": 305.763,
-   "min": 7426.024,
-   "max": 8017.247,
-   "ci95": 759.617
-  },
-  "startup.world_ms": {
-   "n": 3,
-   "mean": 13862.526,
-   "stdev": 284.577,
-   "min": 13569.024,
-   "max": 14137.247,
-   "ci95": 706.985
-  },
-  "chunks.village.load_ms": {
-   "n": 3,
-   "mean": 3808.014,
-   "stdev": 61.275,
-   "min": 3737.989,
-   "max": 3851.799,
-   "ci95": 152.227
-  },
-  "fps.village.avg_fps": {
-   "n": 3,
-   "mean": 2216.576,
-   "stdev": 45.247,
-   "min": 2166.285,
-   "max": 2253.985,
-   "ci95": 112.409
-  },
-  "fps.village.low_1pct_fps": {
-   "n": 3,
-   "mean": 545.307,
-   "stdev": 14.876,
-   "min": 528.15,
-   "max": 554.607,
-   "ci95": 36.957
-  },
-  "fps.village.low_01pct_fps": {
-   "n": 3,
-   "mean": 215.412,
-   "stdev": 5.692,
-   "min": 209.522,
-   "max": 220.882,
-   "ci95": 14.14
-  },
-  "chunks.forest.load_ms": {
-   "n": 3,
-   "mean": 3212.958,
-   "stdev": 151.722,
-   "min": 3076.655,
-   "max": 3376.428,
-   "ci95": 376.928
-  },
-  "fps.forest.avg_fps": {
-   "n": 3,
-   "mean": 2456.542,
-   "stdev": 336.369,
-   "min": 2068.162,
-   "max": 2654.549,
-   "ci95": 835.654
-  },
-  "fps.forest.low_1pct_fps": {
-   "n": 3,
-   "mean": 624.759,
-   "stdev": 90.0,
-   "min": 521.303,
-   "max": 685.008,
-   "ci95": 223.59
-  },
-  "fps.forest.low_01pct_fps": {
-   "n": 3,
-   "mean": 252.469,
-   "stdev": 21.044,
-   "min": 229.228,
-   "max": 270.233,
-   "ci95": 52.28
-  },
-  "chunks.ocean.load_ms": {
-   "n": 3,
-   "mean": 2983.236,
-   "stdev": 168.416,
-   "min": 2788.777,
-   "max": 3082.249,
-   "ci95": 418.403
-  },
-  "fps.ocean.avg_fps": {
-   "n": 3,
-   "mean": 2469.831,
-   "stdev": 333.258,
-   "min": 2085.121,
-   "max": 2669.9,
-   "ci95": 827.925
-  },
-  "fps.ocean.low_1pct_fps": {
-   "n": 3,
-   "mean": 688.684,
-   "stdev": 96.943,
-   "min": 576.803,
-   "max": 747.759,
-   "ci95": 240.839
-  },
-  "fps.ocean.low_01pct_fps": {
-   "n": 3,
-   "mean": 286.444,
-   "stdev": 21.36,
-   "min": 262.183,
-   "max": 302.422,
-   "ci95": 53.066
-  },
-  "chunks.mountain.load_ms": {
-   "n": 3,
-   "mean": 6079.869,
-   "stdev": 719.864,
-   "min": 5542.196,
-   "max": 6897.69,
-   "ci95": 1788.385
-  },
-  "fps.mountain.avg_fps": {
-   "n": 3,
-   "mean": 2605.12,
-   "stdev": 326.424,
-   "min": 2228.824,
-   "max": 2812.075,
-   "ci95": 810.948
-  },
-  "fps.mountain.low_1pct_fps": {
-   "n": 3,
-   "mean": 699.63,
-   "stdev": 87.846,
-   "min": 599.44,
-   "max": 763.45,
-   "ci95": 218.239
-  },
-  "fps.mountain.low_01pct_fps": {
-   "n": 3,
-   "mean": 264.461,
-   "stdev": 28.459,
-   "min": 239.602,
-   "max": 295.503,
-   "ci95": 70.701
-  },
-  "memory.rss_peak_mb": {
-   "n": 3,
-   "mean": 2120.426,
-   "stdev": 116.406,
-   "min": 2046.93,
-   "max": 2254.637,
-   "ci95": 289.191
-  },
-  "memory.rss_steady_mb": {
-   "n": 3,
-   "mean": 1912.642,
-   "stdev": 38.925,
-   "min": 1889.766,
-   "max": 1957.586,
-   "ci95": 96.702
-  }
- },
- "frames": [
-  {
-   "phase": "village",
-   "repeat": 0,
-   "frames": 27048,
-   "seconds": 12.0,
-   "avg_fps": 2253.985,
-   "low_1pct_fps": 553.164,
-   "low_01pct_fps": 215.833,
-   "p50_ms": 0.412,
-   "p95_ms": 0.617,
-   "p99_ms": 1.187,
-   "p999_ms": 2.238,
-   "max_ms": 9.792,
-   "histogram": [
-    26716,
-    296,
-    15,
-    4,
-    7,
-    5,
-    2,
-    2,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 1,
-   "frames": 26754,
-   "seconds": 12.0,
-   "avg_fps": 2229.458,
-   "low_1pct_fps": 554.607,
-   "low_01pct_fps": 220.882,
-   "p50_ms": 0.417,
-   "p95_ms": 0.626,
-   "p99_ms": 1.212,
-   "p999_ms": 2.448,
-   "max_ms": 8.388,
-   "histogram": [
-    26423,
-    293,
-    16,
-    9,
-    4,
-    5,
-    1,
-    1,
-    2,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "village",
-   "repeat": 2,
-   "frames": 25996,
-   "seconds": 12.0,
-   "avg_fps": 2166.285,
-   "low_1pct_fps": 528.15,
-   "low_01pct_fps": 209.522,
-   "p50_ms": 0.43,
-   "p95_ms": 0.662,
-   "p99_ms": 1.308,
-   "p999_ms": 2.477,
-   "max_ms": 11.033,
-   "histogram": [
-    25615,
-    338,
-    23,
-    5,
-    5,
-    5,
-    2,
-    2,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 0,
-   "frames": 31855,
-   "seconds": 12.0,
-   "avg_fps": 2654.549,
-   "low_1pct_fps": 667.966,
-   "low_01pct_fps": 257.945,
-   "p50_ms": 0.341,
-   "p95_ms": 0.519,
-   "p99_ms": 0.932,
-   "p999_ms": 1.761,
-   "max_ms": 10.944,
-   "histogram": [
-    31558,
-    275,
-    6,
-    2,
-    7,
-    0,
-    4,
-    2,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 1,
-   "frames": 31763,
-   "seconds": 12.0,
-   "avg_fps": 2646.916,
-   "low_1pct_fps": 685.008,
-   "low_01pct_fps": 270.233,
-   "p50_ms": 0.344,
-   "p95_ms": 0.52,
-   "p99_ms": 0.94,
-   "p999_ms": 1.685,
-   "max_ms": 11.406,
-   "histogram": [
-    31474,
-    272,
-    3,
-    4,
-    2,
-    2,
-    1,
-    3,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "forest",
-   "repeat": 2,
-   "frames": 24818,
-   "seconds": 12.0,
-   "avg_fps": 2068.162,
-   "low_1pct_fps": 521.303,
-   "low_01pct_fps": 229.228,
-   "p50_ms": 0.439,
-   "p95_ms": 0.767,
-   "p99_ms": 1.284,
-   "p999_ms": 2.351,
-   "max_ms": 11.468,
-   "histogram": [
-    24356,
-    410,
-    36,
-    4,
-    4,
-    3,
-    2,
-    2,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 0,
-   "frames": 32039,
-   "seconds": 12.0,
-   "avg_fps": 2669.9,
-   "low_1pct_fps": 741.491,
-   "low_01pct_fps": 294.727,
-   "p50_ms": 0.345,
-   "p95_ms": 0.501,
-   "p99_ms": 0.86,
-   "p999_ms": 1.431,
-   "max_ms": 9.257,
-   "histogram": [
-    31771,
-    250,
-    3,
-    2,
-    4,
-    6,
-    1,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 1,
-   "frames": 31854,
-   "seconds": 12.0,
-   "avg_fps": 2654.471,
-   "low_1pct_fps": 747.759,
-   "low_01pct_fps": 302.422,
-   "p50_ms": 0.347,
-   "p95_ms": 0.503,
-   "p99_ms": 0.853,
-   "p999_ms": 1.404,
-   "max_ms": 13.925,
-   "histogram": [
-    31580,
-    261,
-    3,
-    2,
-    0,
-    1,
-    3,
-    3,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "ocean",
-   "repeat": 2,
-   "frames": 25022,
-   "seconds": 12.0,
-   "avg_fps": 2085.121,
-   "low_1pct_fps": 576.803,
-   "low_01pct_fps": 262.183,
-   "p50_ms": 0.428,
-   "p95_ms": 0.758,
-   "p99_ms": 1.214,
-   "p999_ms": 2.109,
-   "max_ms": 9.206,
-   "histogram": [
-    24600,
-    390,
-    20,
-    3,
-    2,
-    3,
-    2,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 0,
-   "frames": 33745,
-   "seconds": 12.0,
-   "avg_fps": 2812.075,
-   "low_1pct_fps": 736.0,
-   "low_01pct_fps": 258.279,
-   "p50_ms": 0.327,
-   "p95_ms": 0.471,
-   "p99_ms": 0.808,
-   "p999_ms": 1.689,
-   "max_ms": 10.07,
-   "histogram": [
-    33516,
-    205,
-    7,
-    0,
-    7,
-    4,
-    3,
-    1,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 1,
-   "frames": 33294,
-   "seconds": 12.0,
-   "avg_fps": 2774.461,
-   "low_1pct_fps": 763.45,
-   "low_01pct_fps": 295.503,
-   "p50_ms": 0.334,
-   "p95_ms": 0.471,
-   "p99_ms": 0.813,
-   "p999_ms": 1.63,
-   "max_ms": 8.512,
-   "histogram": [
-    33056,
-    221,
-    3,
-    5,
-    1,
-    2,
-    3,
-    2,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  },
-  {
-   "phase": "mountain",
-   "repeat": 2,
-   "frames": 26747,
-   "seconds": 12.0,
-   "avg_fps": 2228.824,
-   "low_1pct_fps": 599.44,
-   "low_01pct_fps": 239.602,
-   "p50_ms": 0.403,
-   "p95_ms": 0.678,
-   "p99_ms": 1.107,
-   "p999_ms": 2.054,
-   "max_ms": 9.178,
-   "histogram": [
-    26418,
-    298,
-    13,
-    6,
-    2,
-    8,
-    0,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0
-   ]
-  }
- ],
- "label": "vanilla-win-9800x3d-5080"
-}

benchmarks/perf/windows-9800x3d-5080-2026-10-29.md

@@ -1,106 +0,0 @@
-# Horizon v0.2.97 vs vanilla 26.3 on Windows 11: Ryzen 7 9800X3D + RTX 5080 (2026-10-29, RD 8 and 32 rerun 2026-10-30)
-
-The first `tools/perf_bench.py` run on Windows ([docs/benchmark.md](../../docs/benchmark.md)): Horizon, vanilla 26.3 and
-vanilla with performance mods, render distances 8, 16 and 32, 1280x720, three games each, every game from a fresh
-world. The reports are the `*-win-9800x3d-5080-rd*.json` files next to this page.
-
-```sh
-python tools/perf_bench.py --table horizon-win-9800x3d-5080 vanilla-win-9800x3d-5080 vanilla-mods-win-9800x3d-5080
-```
-
-## Setup
-
-- **Machine:** AMD Ryzen 7 9800X3D (8 cores, 16 threads), 94 GB RAM (DDR5, EXPO off), NVIDIA GeForce RTX 5080
-  (driver 617.42), Windows 11 Pro 26200, Balanced power plan, desktop. One 1920x1080 120 Hz display. The game windows
-  were on the desktop of an unlocked session.
-- **Horizon:** release v0.2.97 as the launcher installs it (`--build %APPDATA%\horizon-launcher\versions\v0.2.97`,
-  `--resources` its `.local\horizon-client\26.3`), Vulkan.
-- **Vanilla:** the 26.3 client jar with Fabric Loader 0.19.5 and the driver mod, Java 25.0.5 (Temurin), `-Xmx2G`
-  with the launcher's G1 flags and the manifest's `-XX:StackShadowPages=32`, OpenGL 3.3.
-- **Vanilla + mods:** the same with Sodium mc26.3-0.9.2, Lithium mc26.3-0.26.2, FerriteCore 9.0.0 and
-  ImmediatelyFast 1.17.1 (`tools/benchmark-deps/mods.lock.json`).
-- **Commands:** `python tools/perf_bench.py --game <game> --label <game>-win-9800x3d-5080 --distances <d>
-  --sizes 1280x720 --repeats 3` (plus `--build` and `--resources` for Horizon), with the games taking turns at
-  each distance.
-- **Memory** is the working set on Windows (what Task Manager shows), sampled from outside the process. Horizon's
-  GPU figure is its own Vulkan allocator total. `nvidia-smi` gives no per-process figure under WDDM, so vanilla has
-  none.
-
-## Load
-
-Windows has no load average, so the reports have no `load_avg_1m`. Every game ran on an otherwise idle machine:
-
-- **RD 8 and RD 32** (rerun on 2026-10-30, after the first pass had builds running alongside): a script started each
-  game only once no `rustc`, `cargo`, `link` (or other compiler) process and no other game (`horizon-client`, `java`,
-  `javaw`, Minecraft) was running, and the machine's CPU load had stayed under 15 % in every 5-second sample for
-  30 seconds. During each game it sampled every 2 seconds the machine's CPU load and the CPU of everything outside the
-  benchmark's own processes. A game during which a compiler or another game ran, or other processes used over 15 % of
-  the machine for 10 seconds, was discarded and run again: two of the 20 games were (vanilla + mods at RD 32, a
-  build started during one, background processes during the other).
-- **RD 16** (2026-10-29): no `rustc`, `cargo` or `link` process at any point, the load logged every 5 seconds.
-
-| Game | RD | Mean / max CPU load (machine, the game included) | Other processes' CPU, mean / max | Compiler processes |
-|---|---|---|---|---|
-| Horizon | 8 | 18 % / 49 % | 6 % / 12 % | 0 |
-| Vanilla | 8 | 28 % / 75 % | 7 % / 20 % | 0 |
-| Vanilla + mods | 8 | 30 % / 81 % | 7 % / 20 % | 0 |
-| Horizon | 16 | 29 % / 80 % | – | 0 |
-| Vanilla | 16 | 41 % / 91 % | – | 0 |
-| Vanilla + mods | 16 | 51 % / 90 % | – | 0 |
-| Horizon | 32 | 36 % / 100 % | 5 % / 15 % | 0 |
-| Vanilla | 32 | 39 % / 73 % | 6 % / 18 % | 0 |
-| Vanilla + mods | 32 | 42 % / 88 % | 6 % / 21 % | 0 |
-
-"Other processes" is the machine's load minus the benchmark's own processes (the game and `perf_bench.py`), in
-2-second samples. Most of it is the system's share of the game's own drawing (the graphics driver and the
-compositor), which no process of the benchmark is charged for; the desktop apps left open (a browser, chat apps)
-briefly reached 5 % at most. RD 16's load was logged from outside every 5 seconds, so it has no such split, and its mean includes the time between
-games. Compared with the first pass, the idle RD 8 runs give Horizon about 10 % higher averages and about 50 % higher
-1% lows, and vanilla up to 10 % higher averages.
-
-## Results
-
-Mean of 3 games ± 95% confidence interval. FPS over the 12-second flight at 16 blocks/s (average / 1% low /
-0.1% low):
-
-| RD | scene | Horizon v0.2.97 | Vanilla 26.3 | Vanilla + mods |
-| --- | --- | --- | --- | --- |
-| 8 | forest | 3495 ±276 / 1295 ±397 / 859 ±298 | 2457 ±836 / 625 ±224 / 252 ±52 | 2425 ±65 / 733 ±30 / 250 ±22 |
-| 8 | mountain | 3376 ±67 / 1384 ±168 / 850 ±256 | 2605 ±811 / 700 ±218 / 264 ±71 | 2538 ±167 / 760 ±34 / 241 ±44 |
-| 8 | ocean | 3346 ±147 / 1358 ±237 / 912 ±235 | 2470 ±828 / 689 ±241 / 286 ±53 | 2432 ±82 / 764 ±37 / 262 ±37 |
-| 8 | village | 2942 ±197 / 1271 ±146 / 839 ±94 | 2217 ±112 / 545 ±37 / 215 ±14 | 2104 ±101 / 577 ±84 / 196 ±47 |
-| 16 | forest | 2424 ±138 / 709 ±165 / 401 ±100 | 1912 ±324 / 402 ±89 / 149 ±25 | 1746 ±32 / 461 ±27 / 179 ±9 |
-| 16 | mountain | 1961 ±99 / 537 ±96 / 297 ±75 | 1653 ±153 / 332 ±27 / 113 ±8 | 1500 ±55 / 408 ±40 / 140 ±10 |
-| 16 | ocean | 2201 ±183 / 554 ±251 / 325 ±326 | 1861 ±289 / 446 ±142 / 165 ±29 | 1815 ±119 / 514 ±142 / 192 ±58 |
-| 16 | village | 1712 ±192 / 593 ±80 / 358 ±69 | 1218 ±65 / 318 ±16 / 127 ±5 | 1282 ±162 / 343 ±25 / 132 ±12 |
-| 32 | forest | 1389 ±70 / 504 ±33 / 330 ±118 | 1203 ±51 / 228 ±13 / 108 ±12 | 929 ±8 / 313 ±41 / 129 ±32 |
-| 32 | mountain | 1086 ±34 / 258 ±78 / 108 ±37 | 815 ±61 / 55 ±13 / 8 ±3 | 645 ±10 / 166 ±12 / 86 ±21 |
-| 32 | ocean | 1189 ±27 / 155 ±9 / 68 ±8 | 1223 ±33 / 236 ±17 / 99 ±21 | 1017 ±14 / 325 ±38 / 117 ±28 |
-| 32 | village | 1164 ±9 / 416 ±39 / 216 ±86 | 882 ±48 / 184 ±12 / 83 ±17 | 926 ±17 / 250 ±5 / 93 ±11 |
-
-Startup, loading and memory (means of 3 games):
-
-| RD | | Horizon v0.2.97 | Vanilla 26.3 | Vanilla + mods |
-| --- | --- | --- | --- | --- |
-| 8 | start to title / in-world | 3.0 s / 6.1 s | 7.7 s / 13.9 s | 11.1 s / 17.6 s |
-| 8 | mean scene load | 1.3 s | 4.0 s | 3.6 s |
-| 8 | working set, steady / peak | 1082 / 1172 MB | 1913 / 2120 MB | 1904 / 2053 MB |
-| 16 | start to title / in-world | 3.2 s / 7.2 s | 7.7 s / 19.9 s | 10.8 s / 23.5 s |
-| 16 | mean scene load | 2.4 s | 9.2 s | 9.0 s |
-| 16 | working set, steady / peak | 1236 / 1459 MB | 2300 / 2540 MB | 2327 / 2496 MB |
-| 32 | start to title / in-world | 2.9 s / 10.5 s | 7.5 s / 35.4 s | 11.0 s / 39.2 s |
-| 32 | mean scene load | 5.7 s | 21.1 s | 19.9 s |
-| 32 | working set, steady / peak | 1730 / 2045 MB | 2799 / 2892 MB | 2895 / 2965 MB |
-
-## What it shows
-
-- At RD 8 and 16, Horizon's average FPS is 18–42 % above vanilla's in every scene. Its 1% lows are 1.2–2.3 times
-  vanilla's and its 0.1% lows 2.0–3.9 times. On this CPU and GPU the performance mods leave vanilla's averages
-  level or slightly lower, and raise its 1% lows by 6–23 %.
-- At RD 32, Horizon's average is 15–33 % above vanilla's over the forest, the mountain and the village, with 1% lows
-  2.2–4.7 times vanilla's. Over the ocean its average is level with vanilla's, but its lows are lower than vanilla's
-  and the modded client's (155 vs 236 and 325 FPS 1% low, 68 vs 99 and 117 FPS 0.1% low), on an idle machine too.
-  That scene is worth a closer look.
-- Horizon reaches the title screen 2.4–2.6 times faster than vanilla (3.4–3.8 times faster than the modded client)
-  and loads a scene's chunks 3–4 times faster. Its steady working set is 38–46 % smaller.
-- Each game uses its own graphics API: Horizon Vulkan, vanilla OpenGL. That difference is part of what's compared.

benchmarks/server-equal-mixed-2026-10-18/README.md

@@ -119,7 +119,7 @@ machines during the runs.
 
 ## Reproduce
 
-    curl -fsSL https://raw.githubusercontent.com/horizon-rust/horizon/main/packaging/server/install.sh | sh
+    curl -fsSL https://raw.githubusercontent.com/ludovic111/horizon/main/packaging/server/install.sh | sh
     horizon-prepare --prepare --server-jar /path/to/server.jar      # your own copy
     cargo build --release -p horizon-bots                            # on the machine that runs the bots
     # in a checkout whose .local/minecraft holds the pinned vanilla jars (tools/lab.py prepare):

benchmarks/server-four-way-2026-10-19/README.md

@@ -148,7 +148,7 @@ early, wrote no report. Its lines come from its output.
 
 ## Reproduce
 
-    curl -fsSL https://raw.githubusercontent.com/horizon-rust/horizon/main/packaging/server/install.sh | sh
+    curl -fsSL https://raw.githubusercontent.com/ludovic111/horizon/main/packaging/server/install.sh | sh
     horizon-prepare --prepare --server-jar /path/to/server.jar      # your own copy
     cargo build --release -p horizon-bots                            # on the machine that runs the bots
     # in a checkout whose .local/minecraft holds the pinned vanilla jars (tools/lab.py prepare):

benchmarks/server-mixed-2026-10-18/README.md

@@ -103,7 +103,7 @@ the Nix store, so the run set `LD_LIBRARY_PATH` to them (see #898).
 
 ## Reproduce
 
-    curl -fsSL https://raw.githubusercontent.com/horizon-rust/horizon/main/packaging/server/install.sh | sh
+    curl -fsSL https://raw.githubusercontent.com/ludovic111/horizon/main/packaging/server/install.sh | sh
     horizon-prepare --prepare --server-jar /path/to/server.jar      # your own copy
     cargo build --release -p horizon-bots                            # on the machine that runs the bots
     # in a checkout whose .local/minecraft holds the pinned vanilla jars (tools/lab.py prepare):

crates/cargo-horizon-mod/Cargo.toml

@@ -4,10 +4,10 @@ version = "0.1.0"
 edition.workspace = true
 license.workspace = true
 rust-version = "1.86"
-description = "cargo horizon-mod new/build/run/check: make Horizon content mods (docs/mods.md)"
+description = "cargo horizon-mod new/build/run/check: make Horizon mods in Rust (docs/mods.md)"
 
 [dependencies]
-horizon-mods = { path = "../horizon-mods", default-features = false, features = ["index"] }
+horizon-mods = { path = "../horizon-mods", default-features = false, features = ["pack", "runtime", "index"] }
 serde_json = "1.0.151"
 
 [lints]

crates/cargo-horizon-mod/src/check.rs

@@ -1,19 +1,35 @@
 //! `cargo horizon-mod check <file>`: what the registry checks of a submission,
 //! run anywhere: its kind's own checks (docs/api/mod-index.md), its signature
-//! when given a key, and for a `.hmod` that it is content only.
+//! when given a key, and for a mod a trial run in the sandbox: it must start,
+//! survive ticks, frames, a chat line and each of its commands (a server mod:
+//! a player joining, chatting, typing them and leaving), and import no more
+//! than its capabilities.
 use horizon_mods::{
-    Package,
+    Clock, GameMode, Mods, Output, Package, Player, ServerPlayer, Snapshot, Status,
     index::{self, Facts, Kind},
+    manifest::component_imports,
 };
 use serde_json::{Value, json};
 use std::path::Path;
 
+/// How long the trial run plays: two seconds of game.
+const TICKS: u64 = 40;
+const FRAMES_PER_TICK: u64 = 3;
+
 pub struct Report {
     pub kind: Kind,
     pub facts: Facts,
     pub sha256: String,
     pub size: u64,
     pub signed: bool,
+    /// A mod has code to run (a content mod may have none).
+    pub code: bool,
+    /// A mod's component imports.
+    pub imports: Vec<String>,
+    /// A mod's commands, each run once.
+    pub commands: Vec<String>,
+    /// What the mod showed during the trial run.
+    pub output: Vec<String>,
 }
 
 impl Report {
@@ -37,6 +53,10 @@ impl Report {
             "sha256": self.sha256,
             "size": self.size,
             "signed": self.signed,
+            "code": self.code,
+            "imports": self.imports,
+            "commands": self.commands,
+            "output": self.output,
         })
     }
 
@@ -77,11 +97,18 @@ impl Report {
         for r in &f.requires {
             out += &format!("  needs {} {} ({})\n", r.id, r.version, &r.sha256[..12]);
         }
-        if self.kind == Kind::NativeMod {
-            out += "  native source: unsandboxed; not executed by the registry check. Compile and test against the exact pinned Horizon and Mixins revisions before review.\n";
-        }
-        if self.kind == Kind::Mod {
+        if self.kind == Kind::Mod && !self.code {
             out += "  no code: content only, nothing to run\n";
+        } else if self.kind == Kind::Mod {
+            let commands = if self.commands.is_empty() {
+                String::new()
+            } else {
+                format!(", /{}", self.commands.join(", /"))
+            };
+            out += &format!(
+                "  trial run: started, {TICKS} ticks, {} frames, a chat line{commands}: ok\n",
+                TICKS * FRAMES_PER_TICK
+            );
         }
         out
     }
@@ -91,7 +118,6 @@ impl Report {
 pub fn kind_of(path: &Path) -> Option<Kind> {
     match path.extension()?.to_str()? {
         "hmod" => Some(Kind::Mod),
-        "hnmod" => Some(Kind::NativeMod),
         "hpack" => Some(Kind::Modpack),
         "zip" => Some(Kind::ResourcePack),
         "hshader" => Some(Kind::Shader),
@@ -123,26 +149,145 @@ pub fn check(
         (None, None) => false,
         _ => return Err("--key and --signature go together".into()),
     };
-    if kind == Kind::Mod {
-        content_only(path)?;
-    }
-    Ok(Report {
+    let mut report = Report {
         kind,
         facts,
         sha256: index::sha256_file(path)?,
         size,
         signed,
-    })
+        code: false,
+        imports: Vec::new(),
+        commands: Vec::new(),
+        output: Vec::new(),
+    };
+    if report.kind == Kind::Mod {
+        trial_run(path, &mut report)?;
+    }
+    Ok(report)
 }
 
-/// A mod is content only: WebAssembly code mods don't run any more, code mods are native
-/// (`.hnmod`, docs/native-mods.md). `inspect` already read its content as the game does.
-fn content_only(path: &Path) -> Result<(), String> {
-    match Package::read(path)?.wasm {
-        Some(_) => Err(
-            "it has WebAssembly code, which Horizon doesn't run any more: make it a native mod (docs/native-mods.md)"
-                .into(),
-        ),
+/// Runs a mod in the sandbox, as the game does, from a scratch copy so its
+/// storage lands in a folder removed afterwards. A content mod has no code to
+/// run: `inspect` already read its content as the game does.
+fn trial_run(path: &Path, report: &mut Report) -> Result<(), String> {
+    let package = Package::read(path)?;
+    let Some(wasm) = package.wasm.as_deref() else {
+        return Ok(());
+    };
+    report.code = true;
+    report.imports = component_imports(wasm)?;
+    package
+        .manifest
+        .check_imports(report.imports.iter().map(String::as_str))?;
+    let dir = std::env::temp_dir().join(format!("horizon-mod-check-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
+    let copy = dir.join("mod.hmod");
+    let result = std::fs::copy(path, &copy)
+        .map_err(|e| e.to_string())
+        .and_then(|_| play(&copy, report));
+    let _ = std::fs::remove_dir_all(&dir);
+    result
+}
+
+fn play(path: &Path, report: &mut Report) -> Result<(), String> {
+    let mut mods = Mods::load(&[path.to_path_buf()], |_| true, |_| false);
+    let failed = |mods: &Mods| match &mods.entries()[0].status {
+        Status::Failed(reason) => Some(reason.clone()),
+        _ => None,
+    };
+    if let Some(reason) = failed(&mods) {
+        return Err(format!("it didn't start: {reason}"));
+    }
+    let client: Vec<String> = mods.commands().map(str::to_owned).collect();
+    let server: Vec<String> = mods.server_commands().map(|c| c.name.clone()).collect();
+    report.commands = [client.clone(), server.clone()].concat();
+    // A server mod plays with one player on, who joins, chats and leaves.
+    let steve = ServerPlayer {
+        id: "00000000-0000-4000-8000-000000000001".into(),
+        name: "Steve".into(),
+        x: 0.5,
+        y: 64.0,
+        z: 0.5,
+        dimension: "minecraft:overworld".into(),
+        game_mode: GameMode::Survival,
+        health: 20.0,
+    };
+    let snapshot = |t: u64| Snapshot {
+        player: Some(Player {
+            x: 0.5 + t as f64 * 0.1,
+            y: 64.0,
+            z: 0.5,
+            yaw: 90.0,
+            pitch: 0.0,
+            health: 20.0,
+            food: 20,
+            dimension: "minecraft:overworld".into(),
+        }),
+        clock: Some(Clock {
+            game_time: t,
+            day_time: 1000 + t,
+        }),
+        players: vec![steve.clone()],
+        // The GUI of a 1280 x 720 window at scale 3.
+        gui_size: (427.0, 240.0),
+        ..Snapshot::default()
+    };
+    mods.set_snapshot(snapshot(0));
+    mods.player_joined(&steve);
+    for t in 0..TICKS {
+        mods.set_snapshot(snapshot(t));
+        mods.tick(t);
+        mods.server_tick(t);
+        for _ in 0..FRAMES_PER_TICK {
+            mods.frame(1.0 / 60.0);
+        }
+    }
+    mods.chat("<Steve> hello");
+    mods.player_chat(&steve, "hello");
+    for name in &client {
+        mods.command(name);
+    }
+    for name in &server {
+        mods.server_command(&steve, name);
+    }
+    mods.set_snapshot(Snapshot::default());
+    mods.player_left(&steve);
+    for out in mods.drain() {
+        report.output.push(match out {
+            Output::Chat { text, .. } => format!("chat: {text}"),
+            Output::Tell { text, .. } => format!("tell: {text}"),
+            Output::Broadcast { text, .. } => format!("broadcast: {text}"),
+            Output::Feedback { text, error } | Output::Reply { text, error, .. } => {
+                format!("{}: {text}", if error { "error" } else { "feedback" })
+            }
+            Output::Command { line } => format!("command: /{line}"),
+            Output::QuietCommands { lines, .. } => {
+                format!("{} quiet command(s)", lines.len())
+            }
+            Output::Stopped { reason, .. } => return Err(format!("it stopped: {reason}")),
+            Output::SetBlocks {
+                dimension, blocks, ..
+            } => {
+                format!("set {} block(s) in {dimension}", blocks.len())
+            }
+            Output::OpenScreen { .. } => "opened a screen".to_string(),
+            Output::CloseScreen { .. } => "closed its screen".to_string(),
+            Output::PlaceRecipe { book_id, all } => {
+                format!("placed recipe {book_id}{}", if all { " (all)" } else { "" })
+            }
+            Output::Give { item, count, .. } => format!("gave {count} {item}"),
+            Output::Shake { strength, seconds } => {
+                format!("shook the camera: {strength:.2} for {seconds:.1} s")
+            }
+        });
+    }
+    let shapes = mods.hud_shapes().count();
+    if shapes > 0 {
+        report.output.push(format!("drew {shapes} HUD shape(s)"));
+    }
+    match failed(&mods) {
+        Some(reason) => Err(format!("it stopped: {reason}")),
         None => Ok(()),
     }
 }
@@ -167,7 +312,7 @@ mod tests {
                 .text()
                 .contains("cozy 1.0.0 (modpack, format 1, for 26.3)")
         );
-        // A mod with WebAssembly code is refused: code mods are native.
+        // The fixture mod's code is a stand-in: its manifest reads, its run fails.
         let hmod = fixture("coords_hud-0.1.0.hmod");
         let key = std::fs::read_to_string(fixture("test.pub")).unwrap();
         let sig = std::fs::read_to_string(fixture("coords_hud-0.1.0.hmod.minisig")).unwrap();
@@ -175,7 +320,7 @@ mod tests {
         let e = check(&hmod, Kind::Mod, Some(key), Some(&sig))
             .err()
             .unwrap();
-        assert!(e.contains("native mod"), "{e}");
+        assert!(e.contains("didn't start"), "{e}");
         let e = check(
             &hmod,
             Kind::Mod,

crates/cargo-horizon-mod/src/main.rs

@@ -1,23 +1,34 @@
-//! `cargo horizon-mod`: make Horizon content mods (`docs/modpacks.md`): blocks,
-//! items, data and assets, no code. Code mods are native (docs/native-mods.md).
+//! `cargo horizon-mod`: make Horizon mods in Rust (`docs/mods.md`).
 //!
-//! - `new <path> [--name "Name"]`: a content mod from the template.
-//! - `build`: the `.hmod` in `target/horizon-mod/`, with the mod's `assets/`
-//!   and `data/`.
+//! - `new <path> [--template code|content|lua] [--name "Name"] [--sdk-path <dir>]`:
+//!   a mod from a template: a Rust crate, a content mod (no code), or a Lua mod.
+//! - `build [--debug]`: the `.hmod` in `target/horizon-mod/`, with the mod's
+//!   `assets/` and `data/`; a folder without `Cargo.toml` is content only.
 //! - `run [--game <horizon-client>] [-- <game args>]`: build, then play with
-//!   the mod.
+//!   the mod; run `build` again and the game reloads it.
+//! - `test [--debug] [--hmod <file>] [<name>]`: build, then run the mod's
+//!   `tests/*.toml` scripts in the sandbox, with no game.
 //! - `check <file> [--json]`: what the registry checks of a submission
-//!   (`.hmod`, `.hnmod`, `.hpack`, resource pack `.zip`, `.hshader`).
+//!   (`.hmod`, `.hpack`, resource pack `.zip`), with a trial run for a mod.
 //! - `registry build|review|check|list`: the registry repository's CI.
-use horizon_mods::{Capability, Content, Manifest, Package, manifest::MANIFEST};
+use horizon_mods::{
+    Capability, Content, Manifest, Package,
+    manifest::{MANIFEST, component_imports, componentize},
+    testing::{Script, TestGame},
+};
 mod check;
 mod registry;
 
 use std::{
     path::{Path, PathBuf},
-    process::{Command, ExitCode},
+    process::{Command, ExitCode, Stdio},
 };
 
+const TARGET: &str = "wasm32-unknown-unknown";
+const SDK_GIT: &str = "{ git = \"https://github.com/ludovic111/horizon\" }";
+/// The Lua runtime from the same repository, with the template's capability.
+const LUA_GIT: &str = "{ git = \"https://github.com/ludovic111/horizon\", features = [\"chat\"] }";
+
 fn main() -> ExitCode {
     // Cargo runs `cargo-horizon-mod horizon-mod <args>`.
     let mut args: Vec<String> = std::env::args().skip(1).collect();
@@ -26,13 +37,14 @@ fn main() -> ExitCode {
     }
     let result = match args.first().map(String::as_str) {
         Some("new") => new(&args[1..]),
-        Some("build") => build().map(|p| {
+        Some("build") => build(!args.iter().any(|a| a == "--debug")).map(|p| {
             println!("Built {}", p.display());
         }),
         Some("run") => run(&args[1..]),
+        Some("test") => test(&args[1..]),
         Some("check") => check(&args[1..]),
         Some("registry") => registry::main(&args[1..]),
-        _ => Err("usage: cargo horizon-mod new <path> [--name \"Name\"] | build | run [--game <horizon-client>] [-- <game args>] | check <file> [--kind <kind>] [--key <public key> --signature <file.minisig>] [--json] | registry build|review|check|list".into()),
+        _ => Err("usage: cargo horizon-mod new <path> [--template code|content|lua] | build [--debug] | run [--game <horizon-client>] [-- <game args>] | test [--debug] [--hmod <file>] [<name>] | check <file> [--kind <kind>] [--key <public key> --signature <file.minisig>] [--json] | registry build|review|check|list".into()),
     };
     match result {
         Ok(()) => ExitCode::SUCCESS,
@@ -73,9 +85,39 @@ fn new(args: &[String]) -> Result<(), String> {
         })
         .collect();
     let name = flag(args, "--name").map_or_else(|| base.replace(['-', '_'], " "), str::to_string);
-    let fill = |t: &str| t.replace("{id}", &id).replace("{name}", &name);
+    let (sdk, lua) = match flag(args, "--sdk-path") {
+        Some(p) => {
+            let p = std::fs::canonicalize(p).map_err(|e| format!("--sdk-path {p}: {e}"))?;
+            let lua = p.parent().unwrap_or(&p).join("horizon-mod-lua");
+            (
+                format!("{{ path = {:?} }}", p.display().to_string()),
+                format!(
+                    "{{ path = {:?}, features = [\"chat\"] }}",
+                    lua.display().to_string()
+                ),
+            )
+        }
+        None => (SDK_GIT.to_string(), LUA_GIT.to_string()),
+    };
+    let fill = |t: &str| {
+        t.replace("{crate}", &id.replace('_', "-"))
+            .replace("{id}", &id)
+            .replace("{name}", &name)
+            .replace("{sdk}", &sdk)
+            .replace("{lua}", &lua)
+    };
+    let code = [
+        ("Cargo.toml", include_str!("../template/Cargo.toml.in")),
+        (MANIFEST, include_str!("../template/horizon-mod.toml")),
+        ("src/lib.rs", include_str!("../template/src/lib.rs")),
+        (".gitignore", include_str!("../template/gitignore")),
+        (
+            "tests/hello.toml",
+            include_str!("../template/tests/hello.toml"),
+        ),
+    ];
     // A block copying a vanilla one, with its model, name, loot, recipe and tag.
-    let files = [
+    let content = [
         (
             MANIFEST,
             include_str!("../template/content/horizon-mod.toml"),
@@ -114,12 +156,21 @@ fn new(args: &[String]) -> Result<(), String> {
         ),
         (".gitignore", include_str!("../template/gitignore")),
     ];
-    if flag(args, "--template").is_some_and(|t| t != "content") {
-        return Err(
-            "only content mods are made here: code mods are native (docs/native-mods.md)".into(),
-        );
-    }
-    for (file, text) in files {
+    // The code template's mod, written in Lua.
+    let lua_files = [
+        ("Cargo.toml", include_str!("../template/lua/Cargo.toml.in")),
+        (MANIFEST, include_str!("../template/lua/horizon-mod.toml")),
+        ("src/lib.rs", include_str!("../template/lua/src/lib.rs")),
+        ("main.lua", include_str!("../template/lua/main.lua")),
+        (".gitignore", include_str!("../template/gitignore")),
+    ];
+    let files: &[(&str, &str)] = match flag(args, "--template").unwrap_or("code") {
+        "code" => &code,
+        "content" => &content,
+        "lua" => &lua_files,
+        other => return Err(format!("no template {other}: code, content or lua")),
+    };
+    for &(file, text) in files {
         let file = fill(file);
         let file = file.as_str();
         let to = dir.join(file);
@@ -137,24 +188,29 @@ fn new(args: &[String]) -> Result<(), String> {
     Ok(())
 }
 
-/// Packs the content mod in the current folder into `target/horizon-mod/<id>.hmod`: the
-/// manifest and the files in `assets/` and `data/`.
-fn build() -> Result<PathBuf, String> {
-    build_in(Path::new("."))
+/// Builds the mod in the current folder and packs `target/horizon-mod/<id>.hmod`:
+/// the manifest, the crate's component (none without a `Cargo.toml`: a
+/// content mod) and the files in `assets/` and `data/`.
+fn build(release: bool) -> Result<PathBuf, String> {
+    build_in(Path::new("."), release)
 }
 
-fn build_in(root: &Path) -> Result<PathBuf, String> {
+fn build_in(root: &Path, release: bool) -> Result<PathBuf, String> {
     let manifest_text = std::fs::read_to_string(root.join(MANIFEST))
         .map_err(|e| format!("{MANIFEST}: {e} (run this in a mod's folder)"))?;
     let manifest = Manifest::parse(&manifest_text)?;
-    if root.join("Cargo.toml").exists() {
-        return Err("a Cargo.toml: code mods are native now (docs/native-mods.md)".into());
-    }
-    if !manifest.capabilities.contains(&Capability::Registries) {
+    let (wasm, target_dir) = if root.join("Cargo.toml").exists() {
+        let (wasm, target) = compile(root, release)?;
+        // The game refuses a component importing capabilities the manifest lacks.
+        manifest.check_imports(component_imports(&wasm)?.iter().map(String::as_str))?;
+        (Some(wasm), target)
+    } else if manifest.capabilities.contains(&Capability::Registries) {
+        (None, root.join("target"))
+    } else {
         return Err(format!(
-            "a content mod has capability registries in {MANIFEST}"
+            "no Cargo.toml: only a content mod (capability registries in {MANIFEST}) has no code"
         ));
-    }
+    };
     // The same checks as the game's, and the files in the order it lists them.
     let content = Content::read(root, &manifest)?;
     let mut reader = content.reader()?;
@@ -163,17 +219,60 @@ fn build_in(root: &Path) -> Result<PathBuf, String> {
         files.push((name.as_str(), reader.read(name)?));
     }
     let files: Vec<(&str, &[u8])> = files.iter().map(|(n, b)| (*n, b.as_slice())).collect();
-    let dir = root.join("target/horizon-mod");
+    let dir = target_dir.join("horizon-mod");
     std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
     let path = dir.join(format!("{}.hmod", manifest.id));
     // Write then rename, so a running game never reads half a file.
     let partial = path.with_extension("hmod.partial");
-    let bytes = Package::write_files(&manifest_text, None, &files)?;
+    let bytes = Package::write_files(&manifest_text, wasm.as_deref(), &files)?;
     std::fs::write(&partial, bytes).map_err(|e| e.to_string())?;
     std::fs::rename(&partial, &path).map_err(|e| e.to_string())?;
     Ok(path)
 }
 
+/// Builds the crate for WebAssembly: its component, and Cargo's target folder.
+fn compile(root: &Path, release: bool) -> Result<(Vec<u8>, PathBuf), String> {
+    let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".into());
+    let mut cmd = Command::new(cargo);
+    // The Lua runtime's seeds (crates/horizon-mod-lua): getrandom 0.3
+    // takes a custom source only with this cfg.
+    let flags = std::env::var("CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUSTFLAGS").unwrap_or_default();
+    cmd.env(
+        "CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUSTFLAGS",
+        format!("{flags} --cfg getrandom_backend=\"custom\"").trim(),
+    );
+    cmd.current_dir(root).args([
+        "build",
+        "--lib",
+        "--target",
+        TARGET,
+        "--message-format=json-render-diagnostics",
+    ]);
+    if release {
+        cmd.arg("--release");
+    }
+    let out = cmd
+        .stderr(Stdio::inherit())
+        .output()
+        .map_err(|e| e.to_string())?;
+    if !out.status.success() {
+        return Err(format!(
+            "cargo build failed (is the target installed? rustup target add {TARGET})"
+        ));
+    }
+    let core = String::from_utf8_lossy(&out.stdout)
+        .lines()
+        .filter_map(|l| serde_json::from_str::<serde_json::Value>(l).ok())
+        .filter(|m| m["reason"] == "compiler-artifact")
+        .flat_map(|m| m["filenames"].as_array().cloned().unwrap_or_default())
+        .filter_map(|f| f.as_str().map(PathBuf::from))
+        .rfind(|f| f.extension().is_some_and(|e| e == "wasm"))
+        .ok_or("the build made no .wasm: is the crate a cdylib?")?;
+    let wasm = componentize(&std::fs::read(&core).map_err(|e| e.to_string())?)?;
+    let target = core.ancestors().nth(3).ok_or("unexpected target folder")?;
+    Ok((wasm, target.to_path_buf()))
+}
+
 /// `check <file>`: the registry's checks of a submission, printed; fails
 /// when one does.
 fn check(args: &[String]) -> Result<(), String> {
@@ -205,14 +304,74 @@ fn check(args: &[String]) -> Result<(), String> {
     Ok(())
 }
 
+/// `test`: every `tests/*.toml` script (those whose name holds `<name>`)
+/// against the built mod, or the `.hmod` given with `--hmod`.
+fn test(args: &[String]) -> Result<(), String> {
+    let hmod = match flag(args, "--hmod") {
+        Some(p) => PathBuf::from(p),
+        None => build(!args.iter().any(|a| a == "--debug"))?,
+    };
+    let filter = args
+        .iter()
+        .enumerate()
+        .find(|(i, a)| !a.starts_with("--") && (*i == 0 || args[i - 1] != "--hmod"))
+        .map(|(_, a)| a.as_str());
+    let mut scripts: Vec<PathBuf> = std::fs::read_dir("tests")
+        .map_err(|e| {
+            format!(
+                "tests/: {e} (a mod's tests are tests/<name>.toml: docs/mods.md, \"Testing a mod\")"
+            )
+        })?
+        .filter_map(|e| Some(e.ok()?.path()))
+        .filter(|p| p.extension().is_some_and(|e| e == "toml"))
+        .filter(|p| filter.is_none_or(|f| p.to_string_lossy().contains(f)))
+        .collect();
+    scripts.sort();
+    if scripts.is_empty() {
+        return Err("no tests/*.toml to run".into());
+    }
+    println!(
+        "running {} scripts against {}",
+        scripts.len(),
+        hmod.display()
+    );
+    let mut failed = 0;
+    for path in &scripts {
+        let result = std::fs::read_to_string(path)
+            .map_err(|e| e.to_string())
+            .and_then(|text| Script::parse(&text))
+            .and_then(|script| {
+                let mut game = TestGame::load(&hmod)?;
+                script.run(&mut game)?;
+                Ok(script.steps.len())
+            });
+        match result {
+            Ok(steps) => println!("test {} ... ok ({steps} steps)", path.display()),
+            Err(e) => {
+                failed += 1;
+                println!("test {} ... FAILED\n  {e}", path.display());
+            }
+        }
+    }
+    let passed = scripts.len() - failed;
+    if failed > 0 {
+        return Err(format!("{failed} failed, {passed} passed"));
+    }
+    println!("test result: ok. {passed} passed");
+    Ok(())
+}
+
 fn run(args: &[String]) -> Result<(), String> {
-    let path = build()?;
+    let path = build(true)?;
     let game = flag(args, "--game")
         .map(str::to_string)
         .or_else(|| std::env::var("HORIZON_CLIENT").ok())
         .unwrap_or_else(|| "horizon-client".into());
     let extra = args.iter().skip_while(|a| *a != "--").skip(1);
-    println!("Starting {game} with {}", path.display());
+    println!(
+        "Starting {game} with {} (rebuild with `cargo horizon-mod build` to reload it)",
+        path.display()
+    );
     let status = Command::new(&game)
         .arg("--dev-mod")
         .arg(&path)
@@ -231,6 +390,48 @@ fn run(args: &[String]) -> Result<(), String> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn the_template_is_a_valid_mod() {
+        let dir = std::env::temp_dir().join(format!("horizon-mod-new-{}", std::process::id()));
+        let path = dir.join("My-Mod");
+        new(&[path.display().to_string(), "--name".into(), "My Mod".into()]).unwrap();
+        let manifest =
+            Manifest::parse(&std::fs::read_to_string(path.join(MANIFEST)).unwrap()).unwrap();
+        assert_eq!(
+            (manifest.id.as_str(), manifest.name.as_str()),
+            ("my_mod", "My Mod")
+        );
+        let cargo = std::fs::read_to_string(path.join("Cargo.toml")).unwrap();
+        assert!(cargo.contains("name = \"my-mod\"") && cargo.contains(SDK_GIT));
+        let script = std::fs::read_to_string(path.join("tests/hello.toml")).unwrap();
+        assert_eq!(Script::parse(&script).unwrap().steps.len(), 3);
+        assert!(
+            new(&[path.display().to_string()]).is_err(),
+            "never overwrites"
+        );
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+
+    #[test]
+    fn the_lua_template_is_a_valid_mod() {
+        let dir = std::env::temp_dir().join(format!("horizon-mod-lua-{}", std::process::id()));
+        let path = dir.join("hello-lua");
+        new(&[
+            path.display().to_string(),
+            "--template".into(),
+            "lua".into(),
+        ])
+        .unwrap();
+        let manifest =
+            Manifest::parse(&std::fs::read_to_string(path.join(MANIFEST)).unwrap()).unwrap();
+        assert_eq!(manifest.capabilities, [horizon_mods::Capability::Chat]);
+        let cargo = std::fs::read_to_string(path.join("Cargo.toml")).unwrap();
+        assert!(cargo.contains("horizon-mod-lua = ") && cargo.contains(LUA_GIT));
+        let script = std::fs::read_to_string(path.join("main.lua")).unwrap();
+        assert!(script.contains("horizon.command(\"hello\")"));
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+
     #[test]
     fn the_content_template_builds_and_checks_with_no_code() {
         let dir = std::env::temp_dir().join(format!("horizon-mod-content-{}", std::process::id()));
@@ -242,7 +443,7 @@ mod tests {
         ];
         new(&new_args).unwrap();
         assert!(!path.join("Cargo.toml").exists());
-        let hmod = build_in(&path).unwrap();
+        let hmod = build_in(&path, true).unwrap();
         assert_eq!(hmod, path.join("target/horizon-mod/gems.hmod"));
         let package = Package::read(&hmod).unwrap();
         assert!(package.wasm.is_none());
@@ -254,19 +455,22 @@ mod tests {
         );
         assert_eq!(content.files.len(), 8, "{:?}", content.files);
         let report = check::check(&hmod, check::kind_of(&hmod).unwrap(), None, None).unwrap();
+        assert!(!report.code);
         assert!(
             report.text().contains("no code: content only"),
             "{}",
             report.text()
         );
-        // Code is native now.
-        std::fs::write(path.join("Cargo.toml"), "").unwrap();
-        assert!(build_in(&path).unwrap_err().contains("native"));
+        // Without registries, a mod needs code.
+        let manifest = std::fs::read_to_string(path.join(MANIFEST)).unwrap();
+        let manifest = manifest.replace("[\"registries\"]", "[]");
+        std::fs::write(path.join(MANIFEST), manifest).unwrap();
+        assert!(build_in(&path, true).unwrap_err().contains("no Cargo.toml"));
         assert!(
             new(&[
                 dir.join("x").display().to_string(),
                 "--template".into(),
-                "lua".into()
+                "python".into()
             ])
             .is_err()
         );

crates/cargo-horizon-mod/src/registry.rs

@@ -1,5 +1,5 @@
 //! `cargo horizon-mod registry build|review|check|list`: the registry repository's CI
-//! (`horizon-rust/horizon-mods`, docs/api/mod-index.md). Network-free: the
+//! (`ludovic111/horizon-mods`, docs/api/mod-index.md). Network-free: the
 //! workflow downloads the files and publishes what this writes.
 use horizon_mods::index::{
     FILE_HOST,
@@ -8,7 +8,7 @@ use horizon_mods::index::{
 use std::path::Path;
 
 /// Where the registry's site is published (its icons).
-const SITE: &str = "https://horizon-rust.github.io/horizon-mods/";
+const SITE: &str = "https://ludovic111.github.io/horizon-mods/";
 
 const USAGE: &str = "usage: cargo horizon-mod registry build <checkout> --files <dir> --out <index.json> [--release <url>] [--site <url>] [--generated <time>]
        cargo horizon-mod registry review <base checkout> <head checkout> --author <login> [--json]

crates/cargo-horizon-mod/template/Cargo.toml.in

@@ -0,0 +1,14 @@
+[package]
+name = "{crate}"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+horizon-mod-sdk = {sdk}
+
+[profile.release]
+opt-level = "s"
+lto = true

crates/cargo-horizon-mod/template/horizon-mod.toml

@@ -0,0 +1,12 @@
+id = "{id}"
+name = "{name}"
+version = "0.1.0"
+description = ""
+authors = []
+# The Horizon mod API the SDK targets.
+api = "0.1"
+# client: runs in the player's game.
+side = "client"
+# What the mod may do, shown to players before they turn it on:
+# game-read (position, health, time), chat (show messages), hud (draw text).
+capabilities = ["chat"]

crates/cargo-horizon-mod/template/lua/Cargo.toml.in

@@ -0,0 +1,17 @@
+[package]
+name = "{crate}"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib"]
+
+# The Lua interpreter, built into the mod with main.lua. Its features are the
+# capabilities horizon-mod.toml lists (game-read, chat, hud, storage): keep
+# the two lists the same.
+[dependencies]
+horizon-mod-lua = {lua}
+
+[profile.release]
+opt-level = "s"
+lto = true

crates/cargo-horizon-mod/template/lua/horizon-mod.toml

@@ -0,0 +1,12 @@
+id = "{id}"
+name = "{name}"
+version = "0.1.0"
+description = ""
+authors = []
+# The Horizon mod API the Lua runtime targets.
+api = "0.1"
+# client: runs in the player's game.
+side = "client"
+# What the mod may do, shown to players before they turn it on:
+# game-read (position, health, time), chat (show messages), hud (draw text).
+capabilities = ["chat"]

crates/cargo-horizon-mod/template/lua/main.lua

@@ -0,0 +1,12 @@
+-- {name}: a Horizon mod in Lua (https://playhorizon.dev/docs/mod-code).
+-- Commands come from horizon.command; hooks are global functions:
+-- on_tick(tick), on_frame(seconds), on_command(name, args), on_chat(text).
+
+local greeted = 0
+
+horizon.command("hello")
+
+function on_command(name, args)
+  greeted = greeted + 1
+  horizon.chat.show(string.format("Hello %s! (%d so far)", args, greeted))
+end

crates/cargo-horizon-mod/template/lua/src/lib.rs

@@ -0,0 +1,2 @@
+// The mod is main.lua: this builds it into the mod with its interpreter.
+horizon_mod_lua::lua_mod!("main.lua");

crates/cargo-horizon-mod/template/src/lib.rs

@@ -0,0 +1,19 @@
+use horizon_mod_sdk::{Mod, Registration, chat};
+
+struct MyMod {
+    greeted: u32,
+}
+
+impl Mod for MyMod {
+    fn init() -> Result<(Self, Registration), String> {
+        Ok((MyMod { greeted: 0 }, Registration::new().command("hello")))
+    }
+
+    fn command(&mut self, _name: &str, args: &str) -> Result<Option<String>, String> {
+        self.greeted += 1;
+        chat::show(&format!("Hello {args}! ({} so far)", self.greeted));
+        Ok(None)
+    }
+}
+
+horizon_mod_sdk::export_mod!(MyMod);

crates/cargo-horizon-mod/template/tests/hello.toml

@@ -0,0 +1,14 @@
+# `cargo horizon-mod test` runs every tests/*.toml against the built mod, with no game:
+# steps happen in order, and `expect` checks what the mod showed during the step.
+# Every key: docs/mods.md, "Testing a mod".
+
+[[step]]
+expect.commands = ["hello"]
+
+[[step]]
+command = "hello world"
+expect.chat = ["Hello world! (1 so far)"]
+
+[[step]]
+command = "hello again"
+expect.chat = ["Hello again! (2 so far)"]

crates/horizon-bots/src/main.rs

@@ -21,19 +21,18 @@ use horizon_protocol::{
     connection::{ConnWriter, Connection},
     crypto::offline_uuid,
     ids,
-    item::Stack,
     packets::{
         Empty, configuration,
         handshake::{self, Intention},
         login::{self, ServerHello},
-        play, recipes,
+        play,
     },
 };
 use serde_json::json;
 use std::{
     collections::HashSet,
     sync::{
-        Arc, LazyLock, Mutex,
+        Arc, Mutex,
         atomic::{AtomicBool, AtomicU64, Ordering},
     },
     thread,
@@ -45,71 +44,29 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
 
   --server HOST:PORT     default 127.0.0.1:25565
   --bots N               default 10
-  --behaviour B          idle, walk, explore or mixed (60 % walk, 20 % explore, 20 % idle); default mixed.
-                         stand: stays on the ground where the server puts it (/tp), for a survival test.
-                         One abusive client, to test a server's limits (run it beside a normal crowd):
-                         flood-move (--flood moves a tick, each 64 to 256 blocks away, ignoring chunks),
-                         flood-acks (--flood chunk batch acks asking for 64 chunks a tick, while exploring),
-                         flood-packets (--flood rotations a tick),
-                         flood-chunks (one move a tick, 9.9 blocks straight ahead: as fast as the
-                         moved-too-quickly check allows, never waiting for chunks),
-                         and --flood a tick of packets that cost the server work:
-                         flood-use (place and break stone around itself), flood-click (inventory
-                         clicks with a stale state), flood-suggest (command suggestions, every
-                         other one 30 000 characters long), flood-book (100 pages of 1024 characters
-                         into a writable book), flood-sign (four 384-character lines on the block
-                         below), flood-recipe (recipe book placements)
-  --flood N              packets a tick for the flood behaviours; default 100
-  --attack NAME          attack the player NAME twice a second, from wherever the bot is (a reach test);
-                         the report gives each bot's last health
-  --attack-after S       start attacking S seconds after joining; default 5
-  --no-read              stop reading from the server once spawned (a client that lets the
-                         server's replies pile up)
+  --behaviour B          idle, walk, explore or mixed (60 % walk, 20 % explore, 20 % idle); default mixed
   --join-every SECONDS   default 1
   --seconds N            how long to run after the first bot joins; default 60
   --view-distance N      what the bots ask for; default 10
   --seed N               default 12345
   --explore-speed B      blocks a second an explore bot flies; default 22 (as fast as chunks come)
   --name PREFIX          bot names: PREFIX0, PREFIX1...; default Bot
-  --brand B              the client brand sent in configuration (minecraft:brand); default none
   --report FILE          a JSON summary at the end (- prints it after the per-second lines)
 ";
 
 #[derive(Clone, Copy, Debug, PartialEq)]
 enum Behaviour {
     Idle,
-    Stand,
     Walk,
     Explore,
-    FloodMove,
-    FloodAcks,
-    FloodPackets,
-    FloodChunks,
-    FloodUse,
-    FloodClick,
-    FloodSuggest,
-    FloodBook,
-    FloodSign,
-    FloodRecipe,
 }
 
 impl Behaviour {
     fn name(self) -> &'static str {
         match self {
             Self::Idle => "idle",
-            Self::Stand => "stand",
             Self::Walk => "walk",
             Self::Explore => "explore",
-            Self::FloodMove => "flood-move",
-            Self::FloodAcks => "flood-acks",
-            Self::FloodPackets => "flood-packets",
-            Self::FloodChunks => "flood-chunks",
-            Self::FloodUse => "flood-use",
-            Self::FloodClick => "flood-click",
-            Self::FloodSuggest => "flood-suggest",
-            Self::FloodBook => "flood-book",
-            Self::FloodSign => "flood-sign",
-            Self::FloodRecipe => "flood-recipe",
         }
     }
 }
@@ -124,14 +81,7 @@ struct Options {
     view_distance: i8,
     seed: u64,
     explore_speed: f64,
-    /// The player to attack, and how long after joining to start.
-    attack: Option<String>,
-    attack_after: f64,
-    flood: usize,
-    no_read: bool,
     name: String,
-    /// The `minecraft:brand` to send, if any.
-    brand: Option<String>,
     report: Option<String>,
 }
 
@@ -146,13 +96,8 @@ fn options() -> Result<Options, String> {
         view_distance: 10,
         seed: 12345,
         explore_speed: 22.0,
-        attack: None,
-        attack_after: 5.0,
-        flood: 100,
-        no_read: false,
         name: "Bot".into(),
         report: None,
-        brand: None,
     };
     let mut args = std::env::args().skip(1);
     while let Some(arg) = args.next() {
@@ -160,10 +105,6 @@ fn options() -> Result<Options, String> {
             print!("{HELP}");
             std::process::exit(0);
         }
-        if arg == "--no-read" {
-            o.no_read = true;
-            continue;
-        }
         let value = args.next().ok_or(format!("{arg} needs a value"))?;
         let number = |what: &str| format!("{arg} needs {what}, not {value:?}");
         match arg.as_str() {
@@ -181,35 +122,14 @@ fn options() -> Result<Options, String> {
             "--explore-speed" => {
                 o.explore_speed = value.parse().map_err(|_| number("blocks a second"))?;
             }
-            "--flood" => o.flood = value.parse().map_err(|_| number("packets a tick"))?,
-            "--attack" => o.attack = Some(value),
-            "--attack-after" => o.attack_after = value.parse().map_err(|_| number("seconds"))?,
             "--name" => o.name = value,
             "--report" => o.report = Some(value),
-            "--brand" => o.brand = Some(value),
             _ => return Err(format!("unknown option {arg}; --help lists them")),
         }
     }
-    const BEHAVIOURS: [&str; 15] = [
-        "idle",
-        "walk",
-        "explore",
-        "mixed",
-        "stand",
-        "flood-move",
-        "flood-acks",
-        "flood-packets",
-        "flood-chunks",
-        "flood-use",
-        "flood-click",
-        "flood-suggest",
-        "flood-book",
-        "flood-sign",
-        "flood-recipe",
-    ];
-    if !BEHAVIOURS.contains(&o.behaviour.as_str()) {
+    if !["idle", "walk", "explore", "mixed"].contains(&o.behaviour.as_str()) {
         return Err(format!(
-            "--behaviour {}: use idle, walk, explore, mixed or a flood behaviour (--help lists them)",
+            "--behaviour {}: use idle, walk, explore or mixed",
             o.behaviour
         ));
     }
@@ -236,13 +156,6 @@ struct Bot {
     teleport: Mutex<Option<[f64; 3]>>,
     error: Mutex<Option<String>>,
     joined_after_ms: AtomicU64,
-    /// The bot stopped reading (--no-read).
-    deaf: AtomicBool,
-    /// `--attack`: the target's UUID and, once AddEntity showed it, its entity id.
-    target: Mutex<(Option<u128>, Option<i32>)>,
-    attacks: AtomicU64,
-    /// The last SetHealth.
-    health: Mutex<Option<f32>>,
 }
 
 /// A small deterministic generator (SplitMix64), so every run moves the bots the same way.
@@ -272,89 +185,6 @@ fn raw(id: i32, write: impl FnOnce(&mut Writer)) -> Vec<u8> {
     w.data
 }
 
-/// Item ids of the pinned version (26.3's item registry).
-const STONE: i32 = 1;
-const WRITABLE_BOOK: i32 = 1371;
-
-/// The `i`th packet of a costly flood this tick, the bot at `pos`; none for other behaviours.
-fn costly(
-    behaviour: Behaviour,
-    i: usize,
-    sequence: i32,
-    pos: [f64; 3],
-    random: &mut Random,
-) -> Option<Vec<u8>> {
-    use ids::play::serverbound as sb;
-    static LONG_COMMAND: LazyLock<String> =
-        LazyLock::new(|| format!("/msg {}", "x".repeat(30_000)));
-    static BOOK: LazyLock<Vec<u8>> = LazyLock::new(|| {
-        play::Serverbound::EditBook(play::EditBook {
-            slot: 0,
-            pages: vec!["a".repeat(1024); 100],
-            title: None,
-        })
-        .encode()
-    });
-    let block = pos.map(|v| v.floor() as i32);
-    let packet = match behaviour {
-        Behaviour::FloodUse => {
-            // A block within reach: place stone there, or break what is there.
-            let at = [0, 1, 2].map(|k| block[k] + (random.unit() * 7.0) as i32 - 3);
-            if i % 2 == 0 {
-                play::Serverbound::UseItemOn(play::UseItemOn {
-                    hand: 0,
-                    pos: at,
-                    face: 1,
-                    cursor: [0.5, 1.0, 0.5],
-                    inside: false,
-                    world_border: false,
-                    sequence,
-                })
-            } else {
-                play::Serverbound::PlayerAction(play::PlayerAction {
-                    action: 0,
-                    pos: at,
-                    direction: 1,
-                    sequence,
-                })
-            }
-        }
-        Behaviour::FloodClick => play::Serverbound::ContainerClick(play::ContainerClick {
-            container: 0,
-            state: 0,
-            slot: 36 + (i % 9) as i16,
-            button: 0,
-            input: 0,
-            changed: Vec::new(),
-            carried: None,
-        }),
-        Behaviour::FloodSuggest => {
-            let text = if i % 2 == 0 {
-                "/"
-            } else {
-                LONG_COMMAND.as_str()
-            };
-            return Some(raw(sb::COMMAND_SUGGESTION, |w| {
-                w.varint(sequence);
-                w.string(text);
-            }));
-        }
-        Behaviour::FloodBook => return Some(BOOK.clone()),
-        Behaviour::FloodSign => play::Serverbound::SignUpdate(play::SignUpdate {
-            pos: [block[0], block[1] - 1, block[2]],
-            lines: std::array::from_fn(|_| "a".repeat(384)),
-            front: true,
-        }),
-        Behaviour::FloodRecipe => play::Serverbound::PlaceRecipe(recipes::PlaceRecipe {
-            container: 0,
-            recipe: (i % 2042) as i32,
-            use_max: true,
-        }),
-        _ => return None,
-    };
-    Some(packet.encode())
-}
-
 fn err(e: impl std::fmt::Display) -> String {
     e.to_string()
 }
@@ -422,19 +252,6 @@ fn join(o: &Options, name: &str) -> Result<Connection, String> {
         .encode(),
     )
     .map_err(err)?;
-    // ClientBrandRetriever: vanilla's client says "vanilla", Horizon's "horizon".
-    if let Some(brand) = &o.brand {
-        let mut w = Writer::new();
-        w.string(brand);
-        c.send(
-            &configuration::Serverbound::CustomPayload(configuration::CustomPayload {
-                channel: "minecraft:brand".into(),
-                data: w.data,
-            })
-            .encode(),
-        )
-        .map_err(err)?;
-    }
     loop {
         let (id, body) = c.recv().map_err(err)?;
         let reply = match id {
@@ -462,9 +279,8 @@ fn join(o: &Options, name: &str) -> Result<Connection, String> {
                             payload: None,
                         })
                     }
-                    configuration::Clientbound::Disconnect(p) => {
-                        let reason = horizon_protocol::text::plain(&p.reason, &Default::default());
-                        return Err(format!("disconnected during configuration: {reason}"));
+                    configuration::Clientbound::Disconnect(_) => {
+                        return Err("disconnected during configuration".into());
                     }
                     configuration::Clientbound::FinishConfiguration(_) => {
                         c.send(&configuration::Serverbound::FinishConfiguration(Empty).encode())
@@ -523,12 +339,6 @@ fn read(
     let mut batch = BatchSize::new();
     let mut teleports = 0u64;
     loop {
-        if bot.deaf.load(Ordering::Relaxed) {
-            while bot.online.load(Ordering::SeqCst) {
-                thread::sleep(Duration::from_millis(100));
-            }
-            return;
-        }
         let (id, body) = match reader.recv() {
             Ok(packet) => packet,
             Err(e) => {
@@ -569,21 +379,6 @@ fn read(
                 }
                 Ok(())
             }
-            cb::ADD_ENTITY => {
-                if let Ok(play::Clientbound::AddEntity(p)) = play::Clientbound::decode(id, &body) {
-                    let mut target = lock(&bot.target);
-                    if target.0 == Some(p.uuid) {
-                        target.1 = Some(p.id);
-                    }
-                }
-                Ok(())
-            }
-            cb::SET_HEALTH => {
-                if let Ok(play::Clientbound::SetHealth(p)) = play::Clientbound::decode(id, &body) {
-                    *lock(&bot.health) = Some(p.health);
-                }
-                Ok(())
-            }
             cb::CHUNK_BATCH_START => {
                 batch.started = Instant::now();
                 Ok(())
@@ -671,7 +466,6 @@ fn run_bot(
     };
     let (reader, writer) = connection.split();
     let writer = Arc::new(Mutex::new(writer));
-    lock(&bot.target).0 = o.attack.as_deref().map(offline_uuid);
     bot.online.store(true, Ordering::SeqCst);
     {
         let (writer, bot) = (writer.clone(), bot.clone());
@@ -695,31 +489,12 @@ fn run_bot(
         .store(asked.elapsed().as_millis() as u64, Ordering::SeqCst);
     let send = |body: Vec<u8>| lock(&writer).send(&body).is_ok();
     send(raw(sb::PLAYER_LOADED, |_| {}));
-    bot.deaf.store(o.no_read, Ordering::Relaxed);
-    // What the costly floods need in hand (creative: the server takes the bot's word for it).
-    let tool = match behaviour {
-        Behaviour::FloodUse => Some(Stack::new(STONE, 64)),
-        Behaviour::FloodBook => Some(Stack::new(WRITABLE_BOOK, 1)),
-        _ => None,
-    };
-    if tool.is_some() {
-        send(
-            play::Serverbound::SetCreativeModeSlot(play::SetCreativeModeSlot {
-                slot: 36,
-                item: tool,
-            })
-            .encode(),
-        );
-        send(play::Serverbound::SetCarriedItem(play::SetCarriedItem { slot: 0 }).encode());
-    }
-    let mut sequence = 0;
     let mut random = Random(o.seed ^ (index as u64).wrapping_mul(0x2545_F491_4F6C_DD1D));
     let mut pos = spawn;
     let cruise = spawn[1] + 24.0;
     let heading = random.unit() * std::f64::consts::TAU;
     let mut target = pos;
     let mut next = Instant::now();
-    let (joined, mut tick) = (Instant::now(), 0u64);
     loop {
         if lock(&until).is_some_and(|u| Instant::now() >= u) || !bot.online.load(Ordering::SeqCst) {
             break;
@@ -729,46 +504,13 @@ fn run_bot(
             pos = at;
         }
         let here = ((pos[0].floor() as i32) >> 4, (pos[2].floor() as i32) >> 4);
-        // The abusive client doesn't wait for its chunk, as a real client must.
-        if behaviour == Behaviour::Stand {
-            // Where the server put it, on the ground.
-        } else if behaviour == Behaviour::FloodMove {
-            // The last of these moves goes out below, with the tick's end.
-            pos[1] = cruise;
-            for _ in 1..o.flood.max(1) {
-                let angle = random.unit() * std::f64::consts::TAU;
-                let reach = 64.0 + random.unit() * 192.0;
-                pos[0] += angle.cos() * reach;
-                pos[2] += angle.sin() * reach;
-                send(
-                    play::Serverbound::MovePlayerPos(play::MovePlayerPos {
-                        x: pos[0],
-                        y: pos[1],
-                        z: pos[2],
-                        flags: 0,
-                    })
-                    .encode(),
-                );
-            }
-            let angle = random.unit() * std::f64::consts::TAU;
-            pos[0] += angle.cos() * 128.0;
-            pos[2] += angle.sin() * 128.0;
-        } else if behaviour == Behaviour::FloodChunks {
-            // Up to cruising height first, then just under the server's 10 blocks a tick:
-            // every tick asks for new chunks.
-            if pos[1] < cruise {
-                pos[1] = (pos[1] + 0.5).min(cruise);
-            } else {
-                pos[0] += heading.cos() * 9.9;
-                pos[2] += heading.sin() * 9.9;
-            }
-        } else if !lock(&bot.held).contains(&here) {
+        if !lock(&bot.held).contains(&here) {
             bot.waited.fetch_add(1, Ordering::Relaxed);
         } else if pos[1] < cruise {
             pos[1] = (pos[1] + 0.5).min(cruise);
         } else {
             match behaviour {
-                Behaviour::Idle | Behaviour::Stand => {}
+                Behaviour::Idle => {}
                 Behaviour::Walk => {
                     let (dx, dz) = (target[0] - pos[0], target[2] - pos[2]);
                     let distance = dx.hypot(dz);
@@ -787,37 +529,7 @@ fn run_bot(
                         pos[2] += dz / distance * step;
                     }
                 }
-                Behaviour::FloodMove
-                | Behaviour::FloodChunks
-                | Behaviour::FloodUse
-                | Behaviour::FloodClick
-                | Behaviour::FloodSuggest
-                | Behaviour::FloodBook
-                | Behaviour::FloodSign
-                | Behaviour::FloodRecipe => {}
-                Behaviour::FloodPackets => {
-                    for i in 0..o.flood {
-                        send(
-                            play::Serverbound::MovePlayerRot(play::MovePlayerRot {
-                                yaw: (i % 360) as f32,
-                                pitch: 0.0,
-                                flags: 0,
-                            })
-                            .encode(),
-                        );
-                    }
-                }
-                Behaviour::FloodAcks | Behaviour::Explore => {
-                    if behaviour == Behaviour::FloodAcks {
-                        for _ in 0..o.flood {
-                            send(
-                                play::Serverbound::ChunkBatchReceived(play::ChunkBatchReceived {
-                                    chunks_per_tick: 64.0,
-                                })
-                                .encode(),
-                            );
-                        }
-                    }
+                Behaviour::Explore => {
                     // Flying in creative, by default about 22 blocks a second, which keeps new
                     // chunks coming as fast as the server sends them.
                     let step = o.explore_speed / 20.0;
@@ -826,28 +538,12 @@ fn run_bot(
                 }
             }
         }
-        // The costly floods go out wherever the bot is, chunks or not (--no-read gets none).
-        for i in 0..o.flood {
-            sequence += 1;
-            if let Some(body) = costly(behaviour, i, sequence, pos, &mut random) {
-                send(body);
-            }
-        }
-        let target = lock(&bot.target).1;
-        if let Some(id) = target
-            && joined.elapsed().as_secs_f64() >= o.attack_after
-            && tick % 10 == 0
-        {
-            send(play::Serverbound::Attack(play::Attack { id }).encode());
-            bot.attacks.fetch_add(1, Ordering::Relaxed);
-        }
-        tick += 1;
         let ok = send(
             play::Serverbound::MovePlayerPos(play::MovePlayerPos {
                 x: pos[0],
                 y: pos[1],
                 z: pos[2],
-                flags: u8::from(behaviour == Behaviour::Stand),
+                flags: 0,
             })
             .encode(),
         ) && send(raw(sb::CLIENT_TICK_END, |_| {}));
@@ -871,19 +567,8 @@ fn run_bot(
 fn behaviour_of(mode: &str, index: usize) -> Behaviour {
     match mode {
         "idle" => Behaviour::Idle,
-        "stand" => Behaviour::Stand,
         "walk" => Behaviour::Walk,
         "explore" => Behaviour::Explore,
-        "flood-move" => Behaviour::FloodMove,
-        "flood-acks" => Behaviour::FloodAcks,
-        "flood-packets" => Behaviour::FloodPackets,
-        "flood-chunks" => Behaviour::FloodChunks,
-        "flood-use" => Behaviour::FloodUse,
-        "flood-click" => Behaviour::FloodClick,
-        "flood-suggest" => Behaviour::FloodSuggest,
-        "flood-book" => Behaviour::FloodBook,
-        "flood-sign" => Behaviour::FloodSign,
-        "flood-recipe" => Behaviour::FloodRecipe,
         // mixed: of every five bots, three walk, one explores, one stands.
         _ => match index % 5 {
             0 | 2 | 4 => Behaviour::Walk,
@@ -985,8 +670,6 @@ fn main() {
             "pulled_back": b.pulled_back.load(Ordering::Relaxed),
             "waited_ticks": b.waited.load(Ordering::Relaxed),
             "error": *lock(&b.error),
-            "attacks": b.attacks.load(Ordering::Relaxed),
-            "health": *lock(&b.health),
         })).collect::<Vec<_>>(),
     });
     if o.report.as_deref() == Some("-") {

crates/horizon-client-core/src/block_entity_nbt.rs

@@ -61,16 +61,6 @@ fn f32_tag(v: f32) -> Tag {
     Tag::Float(v.to_bits())
 }
 
-/// `TheEndGatewayBlockEntity.loadAdditional`: BlockPos.CODEC and Level.isInSpawnableBounds.
-pub fn gateway_exit(tag: &Tag) -> Option<[i32; 3]> {
-    let Tag::IntArray(v) = tag else { return None };
-    let p: [i32; 3] = v.as_slice().try_into().ok()?;
-    ((-30_000_000..30_000_000).contains(&p[0])
-        && (-20_000_000..20_000_000).contains(&p[1])
-        && (-30_000_000..30_000_000).contains(&p[2]))
-    .then_some(p)
-}
-
 /// What a block entity reads and writes, in `saveAdditional` order.
 struct Fields<'a> {
     input: &'a Tag,
@@ -434,7 +424,10 @@ pub fn canonical(tag: &Tag) -> Option<Tag> {
         }
         "minecraft:end_gateway" => {
             f.long("Age", 0);
-            f.keep("exit_portal", |t| gateway_exit(t).is_some());
+            f.keep("exit_portal", |t| {
+                is_pos(t)
+                    && matches!(t, Tag::IntArray(v) if v[1].abs() <= 30_000_000 && v[0].abs() <= 30_000_000 && v[2].abs() <= 30_000_000)
+            });
             if flag(tag.get("ExactTeleport")) == Some(true) {
                 f.put("ExactTeleport", boolean(true));
             }
@@ -494,11 +487,7 @@ pub fn canonical(tag: &Tag) -> Option<Tag> {
                     _ => string("minecraft:air"),
                 },
             );
-            // Direction.LEGACY_ID_CODEC: the 3D data value as a byte.
-            f.put(
-                "facing",
-                Tag::Byte(int(tag.get("facing")).unwrap_or(0) as i8),
-            );
+            f.put("facing", Tag::Int(int(tag.get("facing")).unwrap_or(0)));
             f.float("progress", 0.0);
             f.flag("extending", false);
             f.flag("source", false);
@@ -877,23 +866,6 @@ mod tests {
         );
     }
 
-    /// `PistonMovingBlockEntity.saveAdditional`: `facing` through
-    /// `Direction.LEGACY_ID_CODEC` (a byte), `progress` a float.
-    #[test]
-    fn moving_piston_fields_match_vanilla() {
-        let out = canon(
-            "{id:\"minecraft:piston\",x:1,y:2,z:3,blockState:{Name:\"minecraft:stone\"},\
-             facing:5,progress:0.5f,extending:1b,source:0b}",
-        );
-        assert_eq!(out.get("facing"), Some(&Tag::Byte(5)));
-        assert_eq!(out.get("progress"), Some(&f32_tag(0.5)));
-        assert_eq!(out.get("extending"), Some(&Tag::Byte(1)));
-        assert_eq!(out.get("source"), Some(&Tag::Byte(0)));
-        let fresh = canon("{id:\"minecraft:piston\",x:1,y:2,z:3}");
-        assert_eq!(fresh.get("facing"), Some(&Tag::Byte(0)));
-        assert_eq!(fresh.get("blockState"), Some(&string("minecraft:air")));
-    }
-
     #[test]
     fn loot_table_replaces_items_and_zero_seed_is_omitted() {
         let out = canon(

crates/horizon-client-core/src/component.rs

@@ -1,7 +1,6 @@
 //! Text components from commands: `ComponentArgument` reads an SNBT (or JSON)
 //! value, `ComponentSerialization` turns it into styled text.
-use crate::text::{InlineObject, Style, Text, named_color};
-use horizon_world::nbt::Tag;
+use crate::text::{Style, Text, named_color};
 use serde_json::{Map, Value};
 
 /// `SnbtGrammar`, enough for components: compounds, lists, quoted and
@@ -11,18 +10,13 @@ pub fn parse_snbt(input: &str) -> Result<(Value, usize), String> {
     let mut p = Parser {
         s: input.as_bytes(),
         i: 0,
-        depth: 0,
     };
     let v = p.value()?;
     Ok((v, p.i))
 }
-/// Nesting deeper than NBT's own limit (`NbtAccounter`'s 512) is refused
-/// rather than overflowing the stack.
-const SNBT_MAX_DEPTH: usize = 512;
 struct Parser<'a> {
     s: &'a [u8],
     i: usize,
-    depth: usize,
 }
 impl Parser<'_> {
     fn ws(&mut self) {
@@ -46,22 +40,57 @@ impl Parser<'_> {
         self.ws();
         match self.peek() {
             Some(b'{') => {
-                if self.depth >= SNBT_MAX_DEPTH {
-                    return Err(format!("tag nesting too deep at {}", self.i));
+                self.i += 1;
+                let mut map = Map::new();
+                self.ws();
+                if self.peek() == Some(b'}') {
+                    self.i += 1;
+                    return Ok(Value::Object(map));
+                }
+                loop {
+                    self.ws();
+                    let key = self.string()?;
+                    self.expect(b':')?;
+                    map.insert(key, self.value()?);
+                    self.ws();
+                    match self.peek() {
+                        Some(b',') => self.i += 1,
+                        Some(b'}') => {
+                            self.i += 1;
+                            return Ok(Value::Object(map));
+                        }
+                        _ => return Err("expected ',' or '}'".into()),
+                    }
                 }
-                self.depth += 1;
-                let v = self.object();
-                self.depth -= 1;
-                v
             }
             Some(b'[') => {
-                if self.depth >= SNBT_MAX_DEPTH {
-                    return Err(format!("tag nesting too deep at {}", self.i));
+                self.i += 1;
+                let mut list = Vec::new();
+                self.ws();
+                // Typed arrays [B;...], [I;...], [L;...].
+                if matches!(
+                    self.s.get(self.i..self.i + 2),
+                    Some([b'B' | b'I' | b'L', b';'])
+                ) {
+                    self.i += 2;
+                }
+                self.ws();
+                if self.peek() == Some(b']') {
+                    self.i += 1;
+                    return Ok(Value::Array(list));
+                }
+                loop {
+                    list.push(self.value()?);
+                    self.ws();
+                    match self.peek() {
+                        Some(b',') => self.i += 1,
+                        Some(b']') => {
+                            self.i += 1;
+                            return Ok(Value::Array(list));
+                        }
+                        _ => return Err("expected ',' or ']'".into()),
+                    }
                 }
-                self.depth += 1;
-                let v = self.array();
-                self.depth -= 1;
-                v
             }
             Some(b'"' | b'\'') => Ok(Value::String(self.string()?)),
             Some(_) => {
@@ -75,20 +104,10 @@ impl Parser<'_> {
                     _ => {
                         let digits = word
                             .trim_end_matches(['b', 'B', 's', 'S', 'l', 'L', 'f', 'F', 'd', 'D']);
-                        // Only digits (and an exponent) make a number: `nan`
-                        // or `Infinity`, which Rust's parse would take, stays
-                        // a string.
-                        if digits
-                            .bytes()
-                            .any(|c| c.is_ascii_alphabetic() && c != b'e' && c != b'E')
-                        {
-                            Value::String(word)
-                        } else {
-                            match (digits.parse::<i64>(), digits.parse::<f64>()) {
-                                (Ok(n), _) if digits.len() + 1 >= word.len() => Value::from(n),
-                                (_, Ok(f)) if digits.len() + 1 >= word.len() => Value::from(f),
-                                _ => Value::String(word),
-                            }
+                        match (digits.parse::<i64>(), digits.parse::<f64>()) {
+                            (Ok(n), _) if digits.len() + 1 >= word.len() => Value::from(n),
+                            (_, Ok(f)) if digits.len() + 1 >= word.len() => Value::from(f),
+                            _ => Value::String(word),
                         }
                     }
                 })
@@ -96,59 +115,6 @@ impl Parser<'_> {
             None => Err("expected a value".into()),
         }
     }
-    fn object(&mut self) -> Result<Value, String> {
-        self.i += 1;
-        let mut map = Map::new();
-        self.ws();
-        if self.peek() == Some(b'}') {
-            self.i += 1;
-            return Ok(Value::Object(map));
-        }
-        loop {
-            self.ws();
-            let key = self.string()?;
-            self.expect(b':')?;
-            map.insert(key, self.value()?);
-            self.ws();
-            match self.peek() {
-                Some(b',') => self.i += 1,
-                Some(b'}') => {
-                    self.i += 1;
-                    return Ok(Value::Object(map));
-                }
-                _ => return Err("expected ',' or '}'".into()),
-            }
-        }
-    }
-    fn array(&mut self) -> Result<Value, String> {
-        self.i += 1;
-        let mut list = Vec::new();
-        self.ws();
-        // Typed arrays [B;...], [I;...], [L;...].
-        if matches!(
-            self.s.get(self.i..self.i + 2),
-            Some([b'B' | b'I' | b'L', b';'])
-        ) {
-            self.i += 2;
-        }
-        self.ws();
-        if self.peek() == Some(b']') {
-            self.i += 1;
-            return Ok(Value::Array(list));
-        }
-        loop {
-            list.push(self.value()?);
-            self.ws();
-            match self.peek() {
-                Some(b',') => self.i += 1,
-                Some(b']') => {
-                    self.i += 1;
-                    return Ok(Value::Array(list));
-                }
-                _ => return Err("expected ',' or ']'".into()),
-            }
-        }
-    }
     fn unquoted(&mut self) -> String {
         let start = self.i;
         while let Some(c) = self.peek() {
@@ -195,7 +161,6 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style {
                 .and_then(|h| u32::from_str_radix(h, 16).ok())
         });
     }
-    style.shadow_color = o.get("shadow_color").and_then(shadow_color);
     let flag = |k: &str| o.get(k).and_then(Value::as_bool);
     style.bold = flag("bold");
     style.italic = flag("italic");
@@ -208,80 +173,22 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style {
     if let Some(e) = o.get("click_event").and_then(Value::as_object) {
         let text = |k: &str| e.get(k).and_then(Value::as_str).map(str::to_owned);
         style.click = match e.get("action").and_then(Value::as_str) {
-            // ClickEvent.OpenUrl.CODEC: ExtraCodecs.UNTRUSTED_URI allows http and
-            // https only, the scheme in any case (Util.parseAndValidateUntrustedUri).
-            Some("open_url") => text("url")
-                .filter(|u| {
-                    u.split_once(':').is_some_and(|(scheme, _)| {
-                        scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https")
-                    })
-                })
-                .map(crate::text::ClickEvent::OpenUrl),
-            // ClickEvent.ChangePage.CODEC: ExtraCodecs.POSITIVE_INT.
-            Some("change_page") => e
-                .get("page")
-                .and_then(Value::as_i64)
-                .and_then(|p| i32::try_from(p).ok())
-                .filter(|p| *p >= 1)
-                .map(crate::text::ClickEvent::ChangePage),
             Some("suggest_command") => text("command").map(crate::text::ClickEvent::SuggestCommand),
-            Some("run_command") => text("command").map(crate::text::ClickEvent::RunCommand),
             Some("copy_to_clipboard") => {
                 text("value").map(crate::text::ClickEvent::CopyToClipboard)
             }
-            // ClickEvent.ShowDialog.CODEC: a `minecraft:dialog` registry id or
-            // the dialog itself; the server may send it (isAllowedFromServer).
-            Some("show_dialog") => e.get("dialog").map(|dialog| {
-                crate::text::ClickEvent::ShowDialog(crate::scoreboard::json_to_tag(dialog))
-            }),
             _ => None,
         };
     }
-    // HoverEvent.ShowText, ShowItem and ShowEntity.
-    if let Some(e) = o.get("hover_event").and_then(Value::as_object) {
-        match e.get("action").and_then(Value::as_str) {
-            Some("show_text") => {
-                if let Some(value) = e.get("value") {
-                    style.hover = Some(Box::new(to_text(value, &mut |s| Text::literal(s))));
-                }
-            }
-            Some("show_item") if e.get("id").is_some_and(Value::is_string) => {
-                style.hover_item = Some(Box::new(Value::Object(e.clone())));
-            }
-            Some("show_entity") if e.get("id").is_some_and(Value::is_string) => {
-                style.hover_entity = Some(Box::new(Value::Object(e.clone())));
-            }
-            _ => {}
-        }
+    // HoverEvent.ShowText.
+    if let Some(e) = o.get("hover_event").and_then(Value::as_object)
+        && e.get("action").and_then(Value::as_str) == Some("show_text")
+        && let Some(value) = e.get("value")
+    {
+        style.hover = Some(Box::new(to_text(value, &mut |s| Text::literal(s))));
     }
-    style.insertion = o
-        .get("insertion")
-        .and_then(Value::as_str)
-        .map(str::to_owned);
     style
 }
-
-/// `Style.shadow_color`: a packed ARGB int or normalized RGBA array.
-pub(crate) fn shadow_color(value: &Value) -> Option<u32> {
-    if let Some(packed) = value.as_i64() {
-        return i32::try_from(packed).ok().map(|n| n as u32);
-    }
-    let rgba = value.as_array()?;
-    if rgba.len() != 4 {
-        return None;
-    }
-    let channels = rgba
-        .iter()
-        .map(|channel| {
-            // ExtraCodecs.ARGB_COLOR_CODEC reads floats; ARGB.as8BitChannel
-            // floors each normalized channel multiplied by 255.
-            let value = channel.as_f64()? as f32;
-            (value.is_finite() && (0.0..=1.0).contains(&value))
-                .then_some((value * 255.0_f32).floor() as u32)
-        })
-        .collect::<Option<Vec<_>>>()?;
-    Some(channels[3] << 24 | channels[0] << 16 | channels[1] << 8 | channels[2])
-}
 /// `ComponentSerialization.CODEC` decoding into text. `selector` components
 /// are resolved by `resolve` (ComponentUtils.updateForEntity).
 pub fn to_text(v: &Value, resolve: &mut dyn FnMut(&str) -> Text) -> Text {
@@ -322,10 +229,6 @@ pub fn to_text_with(
             let style = object_style(o);
             let content = if let Some(t) = contents(o) {
                 t
-            } else if let Some(object) = inline_object(o, resolve, contents) {
-                let mut text = Text::literal("\u{fffc}");
-                text.spans[0].style.inline_object = Some(object);
-                text
             } else if let Some(t) = o.get("text") {
                 match t {
                     Value::String(s) => Text::literal(s.clone()),
@@ -362,142 +265,16 @@ pub fn to_text_with(
             {
                 out.push(to_text_with(extra, resolve, contents).with_style(&style));
             }
-            if o.contains_key("object") || o.contains_key("player") || o.contains_key("sprite") {
-                out.with_component(Value::Object(o.clone()))
-            } else {
-                out
-            }
+            out
         }
         Value::Null => Text::empty(),
     }
 }
 
-fn inline_object(
-    object: &serde_json::Map<String, Value>,
-    resolve: &mut dyn FnMut(&str) -> Text,
-    contents: &mut dyn FnMut(&serde_json::Map<String, Value>) -> Option<Text>,
-) -> Option<InlineObject> {
-    let kind = object.get("object").and_then(Value::as_str);
-    let fallback = object
-        .get("fallback")
-        .map(|value| to_text_with(value, resolve, contents).plain());
-    match kind {
-        Some("player") | None if object.contains_key("player") => {
-            let profile = object.get("player")?.clone();
-            // PlayerSprite.defaultFallback.
-            let fallback = fallback.unwrap_or_else(|| {
-                match profile
-                    .as_str()
-                    .or_else(|| profile.get("name").and_then(Value::as_str))
-                {
-                    Some(name) => format!("[{name} head]"),
-                    None => "[unknown player head]".to_owned(),
-                }
-            });
-            Some(InlineObject::Player {
-                profile,
-                hat: object.get("hat").and_then(Value::as_bool).unwrap_or(true),
-                fallback,
-            })
-        }
-        Some("atlas") | None if object.contains_key("sprite") => {
-            let atlas = object
-                .get("atlas")
-                .and_then(Value::as_str)
-                .unwrap_or("minecraft:blocks")
-                .to_owned();
-            let sprite = object.get("sprite")?.as_str()?.to_owned();
-            // AtlasSprite.defaultFallback: short names, the atlas unless blocks.
-            let fallback = fallback.unwrap_or_else(|| {
-                let short = |id: &str| match id.split_once(':') {
-                    Some(("minecraft", path)) => path.to_owned(),
-                    Some(_) => id.to_owned(),
-                    None => id.to_owned(),
-                };
-                if short(&atlas) == "blocks" {
-                    format!("[{}]", short(&sprite))
-                } else {
-                    format!("[{}@{}]", short(&sprite), short(&atlas))
-                }
-            });
-            Some(InlineObject::Atlas {
-                atlas,
-                sprite,
-                fallback,
-            })
-        }
-        _ => None,
-    }
-}
-
-/// `CustomName` as text: a string keeps its legacy formatting codes, anything
-/// else is a component (`ComponentSerialization`).
-pub fn name_text(tag: &Tag) -> Text {
-    match tag {
-        Tag::String(s) => Text::legacy(&s.to_string_lossy()),
-        t => crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(t)),
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[test]
-    fn shadow_color_accepts_packed_and_rgba_styles() {
-        let packed = serde_json::json!({"text": "A", "shadow_color": -16711936});
-        let text = to_text(&packed, &mut |_| Text::empty());
-        assert_eq!(text.spans[0].style.shadow_color, Some(0xff00ff00));
-        assert_eq!(text.component()["shadow_color"], -16711936);
-        let rgba = serde_json::json!({"text": "A", "shadow_color": [1, 0, 0.5, 1]});
-        let text = to_text(&rgba, &mut |_| Text::empty());
-        assert_eq!(text.spans[0].style.shadow_color, Some(0xffff007f));
-        let translucent = serde_json::json!({"text": "A", "shadow_color": [1, 0, 0.5, 0.5]});
-        let text = to_text(&translucent, &mut |_| Text::empty());
-        assert_eq!(text.spans[0].style.shadow_color, Some(0x7fff007f));
-        let no_shadow = serde_json::json!({"text": "A", "shadow_color": 0});
-        let text = to_text(&no_shadow, &mut |_| Text::empty());
-        assert_eq!(text.spans[0].style.shadow_color, Some(0));
-    }
-
-    #[test]
-    fn player_object_survives_text_parsing_and_keeps_its_siblings() {
-        let component = serde_json::json!({
-            "text": "<",
-            "extra": [
-                {"object": "player", "player": {"name": "elyapluggin"}, "hat": false,
-                 "fallback": "[head]"},
-                {"text": " >", "color": "gold"}
-            ]
-        });
-        let text = to_text(&component, &mut |_| Text::empty());
-        assert_eq!(text.plain(), "<[head] >");
-        assert!(matches!(
-            &text.spans[1].style.inline_object,
-            Some(InlineObject::Player { hat: false, .. })
-        ));
-        assert!(text.spans[2].style.inline_object.is_none());
-        assert_eq!(text.component(), component);
-        let sprite = serde_json::json!({"object": "atlas", "sprite": "minecraft:item/porkchop"});
-        let text = to_text(&sprite, &mut |_| Text::empty());
-        assert!(matches!(
-            &text.spans[0].style.inline_object,
-            Some(InlineObject::Atlas { sprite, .. }) if sprite == "minecraft:item/porkchop"
-        ));
-        // ObjectContents.visit without a fallback: the sprite's defaultFallback.
-        assert_eq!(text.plain(), "[item/porkchop]");
-        let head = serde_json::json!({"object": "player", "player": {"name": "Steve"}});
-        assert_eq!(
-            to_text(&head, &mut |_| Text::empty()).plain(),
-            "[Steve head]"
-        );
-        let gui = serde_json::json!({"atlas": "gui", "sprite": "hud/heart/full"});
-        assert_eq!(
-            to_text(&gui, &mut |_| Text::empty()).plain(),
-            "[hud/heart/full@gui]"
-        );
-    }
-
     #[test]
     fn snbt_and_json_components() {
         let input = "{text:'Hi ',color:red,extra:[{text:\"there\",bold:1b}]} rest";
@@ -531,22 +308,4 @@ mod tests {
         let t = to_text(&v, &mut |_| Text::empty());
         assert_eq!(t.spans[0].style.font, None);
     }
-
-    #[test]
-    fn snbt_nesting_is_bounded() {
-        let nest = |n: usize| format!("{}1{}", "[".repeat(n), "]".repeat(n));
-        assert!(parse_snbt(&nest(512)).is_ok());
-        assert!(parse_snbt(&nest(513)).is_err());
-        assert!(parse_snbt(&nest(100_000)).is_err());
-    }
-
-    #[test]
-    fn bare_words_that_look_numeric_stay_strings() {
-        let (v, _) = parse_snbt("{text:nan}").unwrap();
-        assert_eq!(v["text"], Value::String("nan".into()));
-        let (v, _) = parse_snbt("{text:Infinity}").unwrap();
-        assert_eq!(v["text"], Value::String("Infinity".into()));
-        let (v, _) = parse_snbt("{n:1.5}").unwrap();
-        assert_eq!(v["n"], Value::from(1.5));
-    }
 }

crates/horizon-client-core/src/identifier.rs

@@ -16,20 +16,3 @@ pub fn parse_identifier(raw: &str) -> Option<String> {
     });
     (ns_ok && path_ok).then(|| format!("{ns}:{path}"))
 }
-
-/// `Identifier.CODEC` parsing an entity id: lowercase namespace and path
-/// characters, `minecraft` when the namespace is left out.
-pub fn normalize_id(s: &str) -> Option<String> {
-    let (ns, path) = match s.split_once(':') {
-        Some((ns, path)) => (if ns.is_empty() { "minecraft" } else { ns }, path),
-        None => ("minecraft", s),
-    };
-    let ok = |c: char, slash: bool| {
-        c.is_ascii_lowercase()
-            || c.is_ascii_digit()
-            || matches!(c, '_' | '-' | '.')
-            || slash && c == '/'
-    };
-    (ns.chars().all(|c| ok(c, false)) && path.chars().all(|c| ok(c, true)))
-        .then(|| format!("{ns}:{path}"))
-}

crates/horizon-client-core/src/lang.rs

@@ -4,10 +4,7 @@
 //! language used by every screen.
 use std::{
     collections::{BTreeMap, HashMap},
-    sync::{
-        Arc, RwLock,
-        atomic::{AtomicBool, Ordering},
-    },
+    sync::{Arc, RwLock},
 };
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -26,24 +23,15 @@ impl LanguageInfo {
 #[derive(Default)]
 pub struct Language {
     pub code: String,
-    /// `LanguageInfo.bidirectional`: text without a strong character reads
-    /// right to left (`ClientLanguage.defaultRightToLeft`).
-    bidirectional: bool,
     map: HashMap<String, String>,
 }
 pub const DEFAULT: &str = "en_us";
 
 static CURRENT: RwLock<Option<Arc<Language>>> = RwLock::new(None);
-/// The current language's `bidirectional`, read for every drawn string.
-static BIDIRECTIONAL: AtomicBool = AtomicBool::new(false);
 
 /// A source of resource files: the prepared root plus packs, highest priority last.
 pub trait ResourceSource {
     fn read(&self, path: &str) -> Option<Vec<u8>>;
-    /// Whether `path` is there, without reading it where the source can tell.
-    fn exists(&self, path: &str) -> bool {
-        self.read(path).is_some()
-    }
     /// The namespaces under `assets/` (resource packs may add their own).
     fn namespaces(&self) -> Vec<String> {
         vec!["minecraft".into()]
@@ -60,12 +48,6 @@ impl ResourceSource for Bundled {
             "assets/horizon/lang/ru_ru.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/ru_ru.json")
             }
-            "assets/horizon/lang/pl_pl.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/pl_pl.json")
-            }
-            "assets/horizon/lang/uk_ua.json" => {
-                include_str!("../../horizon-client/assets/horizon/lang/uk_ua.json")
-            }
             _ => return None,
         };
         Some(body.as_bytes().to_vec())
@@ -78,9 +60,6 @@ impl ResourceSource for std::path::PathBuf {
     fn read(&self, path: &str) -> Option<Vec<u8>> {
         std::fs::read(self.join(path)).ok()
     }
-    fn exists(&self, path: &str) -> bool {
-        self.join(path).is_file()
-    }
     fn namespaces(&self) -> Vec<String> {
         std::fs::read_dir(self.join("assets"))
             .into_iter()
@@ -155,12 +134,8 @@ impl Language {
         {
             apply_deprecated(&mut map, &bytes);
         }
-        let bidirectional = available(sources)
-            .iter()
-            .any(|info| info.code == code && info.bidirectional);
         Self {
             code: code.to_owned(),
-            bidirectional,
             map,
         }
     }
@@ -203,7 +178,7 @@ pub fn available(sources: &[&dyn ResourceSource]) -> Vec<LanguageInfo> {
             for (code, info) in value["language"].as_object().into_iter().flatten() {
                 // Only languages whose file exists somewhere are selectable.
                 let file = format!("assets/minecraft/lang/{code}.json");
-                if code != DEFAULT && !sources.iter().any(|s| s.exists(&file)) {
+                if code != DEFAULT && !sources.iter().any(|s| s.read(&file).is_some()) {
                     continue;
                 }
                 found.insert(
@@ -222,16 +197,11 @@ pub fn available(sources: &[&dyn ResourceSource]) -> Vec<LanguageInfo> {
 }
 
 pub fn set(language: Language) {
-    BIDIRECTIONAL.store(language.bidirectional, Ordering::Relaxed);
     *CURRENT.write().unwrap_or_else(|e| e.into_inner()) = Some(Arc::new(language));
 }
 pub fn current() -> Option<Arc<Language>> {
     CURRENT.read().unwrap_or_else(|e| e.into_inner()).clone()
 }
-/// `ClientLanguage.defaultRightToLeft` of the current language.
-pub fn bidirectional() -> bool {
-    BIDIRECTIONAL.load(Ordering::Relaxed)
-}
 pub fn code() -> String {
     current().map_or_else(|| DEFAULT.to_owned(), |l| l.code.clone())
 }
@@ -272,21 +242,6 @@ mod tests {
         assert_eq!(en.get("horizon.options.controller"), Some("Controller"));
         let ru = Language::load(&[&empty], "ru_ru");
         assert_eq!(ru.get("horizon.options.controller"), Some("Геймпад"));
-        // Every bundled string carries both languages: a key added to one file
-        // and forgotten in the other shows as a key name on screen.
-        for key in en.map().keys() {
-            assert!(ru.get(key).is_some(), "{key} has no ru_ru value");
-        }
-        assert_eq!(en.get("horizon.pages.mods"), Some("Mods"));
-        assert_eq!(ru.get("horizon.pages.mods"), Some("Моды"));
-        let pl = Language::load(&[&empty], "pl_pl");
-        assert_eq!(pl.get("horizon.options.controller"), Some("Kontroler"));
-        assert_eq!(pl.get("horizon.options.vibration"), Some("Wibracje"));
-        let uk = Language::load(&[&empty], "uk_ua");
-        assert_eq!(
-            uk.get("horizon.options.on_screen_keyboard"),
-            Some("Екранна клавіатура")
-        );
     }
 
     #[test]
@@ -312,26 +267,4 @@ mod tests {
         );
         assert_eq!(langs[1].label(), "Français (France)");
     }
-
-    #[test]
-    fn languages_are_listed_without_reading_their_files() {
-        struct NoLangReads;
-        impl ResourceSource for NoLangReads {
-            fn read(&self, path: &str) -> Option<Vec<u8>> {
-                assert!(!path.contains("/lang/"), "read {path}");
-                (path == "assets/pack.mcmeta").then(|| {
-                    br#"{"language":{"fr_fr":{"name":"French"},"de_de":{"name":"German"}}}"#
-                        .to_vec()
-                })
-            }
-            fn exists(&self, path: &str) -> bool {
-                path == "assets/minecraft/lang/fr_fr.json"
-            }
-        }
-        let langs = available(&[&NoLangReads]);
-        assert_eq!(
-            langs.iter().map(|l| l.code.as_str()).collect::<Vec<_>>(),
-            ["en_us", "fr_fr"]
-        );
-    }
 }

crates/horizon-client-core/src/lib.rs

@@ -1,9 +1,8 @@
 //! The client's lowest layer, below commands and gameplay: chat text and
 //! translations, SNBT and NBT paths, text components, the scoreboard, boss
 //! bars, game rules, block entity NBT tables, and the registry, particle and
-//! sound source tables commands name, and the `pack.mcmeta` filter regex.
-//! horizon-client re-exports each module under its old path
-//! (`horizon_client::text`, ...).
+//! sound source tables commands name. horizon-client re-exports each module
+//! under its old path (`horizon_client::text`, ...).
 #![forbid(unsafe_code)]
 pub mod block_entity_nbt;
 pub mod bossbar;
@@ -14,15 +13,11 @@ pub mod identifier;
 pub mod key_display;
 pub mod lang;
 pub mod nbt_path;
-pub mod nbt_value;
 pub mod particle_type;
-pub mod pattern;
-pub mod potions;
 pub mod registries;
 pub mod scoreboard;
 pub mod snbt;
 pub mod sound_source;
 pub mod text;
 pub mod uuid;
-pub mod who;
 pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;

crates/horizon-client-core/src/nbt_value.rs

@@ -1,32 +0,0 @@
-//! Reading and writing single NBT values the way vanilla's codecs accept them.
-use horizon_world::nbt::Tag;
-
-pub fn string(s: &str) -> Tag {
-    Tag::String(s.into())
-}
-pub fn text(tag: Option<&Tag>) -> Option<String> {
-    match tag {
-        Some(Tag::String(s)) => Some(s.to_string_lossy()),
-        _ => None,
-    }
-}
-/// Any numeric tag as i64 (vanilla's `getIntOr` etc. accept every number type).
-pub fn number(tag: Option<&Tag>) -> Option<i64> {
-    Some(match tag? {
-        Tag::Byte(v) => i64::from(*v),
-        Tag::Short(v) => i64::from(*v),
-        Tag::Int(v) => i64::from(*v),
-        Tag::Long(v) => *v,
-        Tag::Float(b) => f32::from_bits(*b) as i64,
-        Tag::Double(b) => f64::from_bits(*b) as i64,
-        _ => return None,
-    })
-}
-/// Any numeric tag as f64, keeping a float's or double's fraction.
-pub fn float(tag: Option<&Tag>) -> Option<f64> {
-    Some(match tag? {
-        Tag::Float(b) => f64::from(f32::from_bits(*b)),
-        Tag::Double(b) => f64::from_bits(*b),
-        other => number(Some(other))? as f64,
-    })
-}

crates/horizon-client-core/src/particle_type.rs

@@ -55,12 +55,6 @@ particle_types! {
     Rain = "rain",
     Bubble = "bubble",
     SulfurBubbles = "sulfur_bubbles",
-    NoxiousGas = "noxious_gas",
-    NoxiousGasCloud = "noxious_gas_cloud",
-    Geyser = "geyser",
-    GeyserBase = "geyser_base",
-    GeyserPoof = "geyser_poof",
-    GeyserPlume = "geyser_plume",
     BubblePop = "bubble_pop",
     BubbleColumnUp = "bubble_column_up",
     CurrentDown = "current_down",
@@ -155,10 +149,6 @@ impl ParticleType {
         matches!(
             self,
             Self::BlockMarker
-                | Self::Geyser
-                | Self::GeyserBase
-                | Self::GeyserPoof
-                | Self::GeyserPlume
                 | Self::DamageIndicator
                 | Self::ExplosionEmitter
                 | Self::Explosion
@@ -201,8 +191,6 @@ impl ParticleType {
             // SpellParticle.
             | Self::Effect | Self::InstantEffect | Self::EntityEffect
             | Self::Witch | Self::Infested | Self::TrialOmen | Self::RaidOmen
-            // NoxiousGasParticle.
-            | Self::NoxiousGas
             // EmissiveRisingParticle.
             | Self::Soul | Self::SculkSoul
             // SculkChargeParticle, SculkChargePopParticle, ShriekParticle,

crates/horizon-client-core/src/potions.rs

@@ -1,250 +0,0 @@
-//! The `MobEffects` and `Potions` registries (code in vanilla, ported as
-//! tables): each effect's colour and category, each potion's effects, and the
-//! potion colour mix. horizon-client re-exports them from `brewing`.
-use std::{collections::HashMap, sync::OnceLock};
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Category {
-    Beneficial,
-    Harmful,
-    Neutral,
-}
-/// A `MobEffect`: id (without namespace), colour, category, instantaneous.
-#[derive(Clone, Copy, Debug)]
-pub struct EffectDef {
-    pub id: &'static str,
-    pub color: u32,
-    pub category: Category,
-    pub instant: bool,
-}
-const fn fx(id: &'static str, color: u32, category: Category) -> EffectDef {
-    EffectDef {
-        id,
-        color,
-        category,
-        instant: false,
-    }
-}
-use Category::{Beneficial as B, Harmful as H, Neutral as N};
-/// `MobEffects` in registration order.
-pub const EFFECTS: &[EffectDef] = &[
-    fx("speed", 3402751, B),
-    fx("slowness", 9154528, H),
-    fx("haste", 14270531, B),
-    fx("mining_fatigue", 4866583, H),
-    fx("strength", 16762624, B),
-    EffectDef {
-        id: "instant_health",
-        color: 16262179,
-        category: B,
-        instant: true,
-    },
-    EffectDef {
-        id: "instant_damage",
-        color: 11101546,
-        category: H,
-        instant: true,
-    },
-    fx("jump_boost", 16646020, B),
-    fx("nausea", 5578058, H),
-    fx("regeneration", 13458603, B),
-    fx("resistance", 9520880, B),
-    fx("fire_resistance", 16750848, B),
-    fx("water_breathing", 10017472, B),
-    fx("invisibility", 16185078, B),
-    fx("blindness", 2039587, H),
-    fx("night_vision", 12779366, B),
-    fx("hunger", 5797459, H),
-    fx("weakness", 4738376, H),
-    fx("poison", 8889187, H),
-    fx("wither", 7561558, H),
-    fx("health_boost", 16284963, B),
-    fx("absorption", 2445989, B),
-    EffectDef {
-        id: "saturation",
-        color: 16262179,
-        category: B,
-        instant: true,
-    },
-    fx("glowing", 9740385, N),
-    fx("levitation", 13565951, H),
-    fx("luck", 5882118, B),
-    fx("unluck", 12624973, H),
-    fx("slow_falling", 15978425, B),
-    fx("conduit_power", 1950417, B),
-    fx("dolphins_grace", 8954814, B),
-    fx("bad_omen", 745784, N),
-    fx("hero_of_the_village", 4521796, B),
-    fx("darkness", 2696993, H),
-    fx("trial_omen", 1484454, N),
-    fx("raid_omen", 14565464, N),
-    fx("wind_charged", 12438015, H),
-    fx("weaving", 7891290, H),
-    fx("oozing", 10092451, H),
-    fx("infested", 9214860, H),
-    fx("breath_of_the_nautilus", 65518, B),
-];
-pub fn effect(id: &str) -> Option<&'static EffectDef> {
-    let id = id.trim_start_matches("minecraft:");
-    EFFECTS.iter().find(|e| e.id == id)
-}
-/// Namespaced effect ids for mob effect storage.
-pub fn namespaced(id: &'static str) -> &'static str {
-    static IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
-    let key = id.strip_prefix("minecraft:").unwrap_or(id);
-    IDS.get_or_init(|| {
-        EFFECTS
-            .iter()
-            .map(|e| {
-                (
-                    e.id,
-                    &*Box::leak(format!("minecraft:{}", e.id).into_boxed_str()),
-                )
-            })
-            .collect()
-    })
-    .get(key)
-    .copied()
-    .unwrap_or(id)
-}
-/// A `Potion`: id, name suffix (`item.minecraft.potion.effect.<name>`) and
-/// effects as (effect, duration ticks, amplifier).
-#[derive(Clone, Copy, Debug)]
-pub struct PotionDef {
-    pub id: &'static str,
-    pub name: &'static str,
-    pub effects: &'static [(&'static str, i32, i32)],
-}
-const fn p(
-    id: &'static str,
-    name: &'static str,
-    effects: &'static [(&'static str, i32, i32)],
-) -> PotionDef {
-    PotionDef { id, name, effects }
-}
-/// `Potions` in registration order.
-pub const POTIONS: &[PotionDef] = &[
-    p("water", "water", &[]),
-    p("mundane", "mundane", &[]),
-    p("thick", "thick", &[]),
-    p("awkward", "awkward", &[]),
-    p("night_vision", "night_vision", &[("night_vision", 3600, 0)]),
-    p(
-        "long_night_vision",
-        "night_vision",
-        &[("night_vision", 9600, 0)],
-    ),
-    p("invisibility", "invisibility", &[("invisibility", 3600, 0)]),
-    p(
-        "long_invisibility",
-        "invisibility",
-        &[("invisibility", 9600, 0)],
-    ),
-    p("leaping", "leaping", &[("jump_boost", 3600, 0)]),
-    p("long_leaping", "leaping", &[("jump_boost", 9600, 0)]),
-    p("strong_leaping", "leaping", &[("jump_boost", 1800, 1)]),
-    p(
-        "fire_resistance",
-        "fire_resistance",
-        &[("fire_resistance", 3600, 0)],
-    ),
-    p(
-        "long_fire_resistance",
-        "fire_resistance",
-        &[("fire_resistance", 9600, 0)],
-    ),
-    p("swiftness", "swiftness", &[("speed", 3600, 0)]),
-    p("long_swiftness", "swiftness", &[("speed", 9600, 0)]),
-    p("strong_swiftness", "swiftness", &[("speed", 1800, 1)]),
-    p("slowness", "slowness", &[("slowness", 1800, 0)]),
-    p("long_slowness", "slowness", &[("slowness", 4800, 0)]),
-    p("strong_slowness", "slowness", &[("slowness", 400, 3)]),
-    p(
-        "turtle_master",
-        "turtle_master",
-        &[("slowness", 400, 3), ("resistance", 400, 2)],
-    ),
-    p(
-        "long_turtle_master",
-        "turtle_master",
-        &[("slowness", 800, 3), ("resistance", 800, 2)],
-    ),
-    p(
-        "strong_turtle_master",
-        "turtle_master",
-        &[("slowness", 400, 5), ("resistance", 400, 3)],
-    ),
-    p(
-        "water_breathing",
-        "water_breathing",
-        &[("water_breathing", 3600, 0)],
-    ),
-    p(
-        "long_water_breathing",
-        "water_breathing",
-        &[("water_breathing", 9600, 0)],
-    ),
-    p("healing", "healing", &[("instant_health", 1, 0)]),
-    p("strong_healing", "healing", &[("instant_health", 1, 1)]),
-    p("harming", "harming", &[("instant_damage", 1, 0)]),
-    p("strong_harming", "harming", &[("instant_damage", 1, 1)]),
-    p("poison", "poison", &[("poison", 900, 0)]),
-    p("long_poison", "poison", &[("poison", 1800, 0)]),
-    p("strong_poison", "poison", &[("poison", 432, 1)]),
-    p("regeneration", "regeneration", &[("regeneration", 900, 0)]),
-    p(
-        "long_regeneration",
-        "regeneration",
-        &[("regeneration", 1800, 0)],
-    ),
-    p(
-        "strong_regeneration",
-        "regeneration",
-        &[("regeneration", 450, 1)],
-    ),
-    p("strength", "strength", &[("strength", 3600, 0)]),
-    p("long_strength", "strength", &[("strength", 9600, 0)]),
-    p("strong_strength", "strength", &[("strength", 1800, 1)]),
-    p("weakness", "weakness", &[("weakness", 1800, 0)]),
-    p("long_weakness", "weakness", &[("weakness", 4800, 0)]),
-    p("luck", "luck", &[("luck", 6000, 0)]),
-    p("slow_falling", "slow_falling", &[("slow_falling", 1800, 0)]),
-    p(
-        "long_slow_falling",
-        "slow_falling",
-        &[("slow_falling", 4800, 0)],
-    ),
-    p("wind_charged", "wind_charged", &[("wind_charged", 3600, 0)]),
-    p("weaving", "weaving", &[("weaving", 3600, 0)]),
-    p("oozing", "oozing", &[("oozing", 3600, 0)]),
-    p("infested", "infested", &[("infested", 3600, 0)]),
-];
-pub fn potion(id: &str) -> Option<&'static PotionDef> {
-    let id = id.trim_start_matches("minecraft:");
-    POTIONS.iter().find(|p| p.id == id)
-}
-/// `PotionContents.BASE_POTION_COLOR` (ARGB -13083194) as RGB.
-pub const BASE_POTION_COLOR: u32 = 0x385DC6;
-/// `PotionContents.getColor`: amplifier-weighted mix of visible effect colours.
-pub fn potion_color(id: Option<&str>) -> u32 {
-    let Some(def) = id.and_then(potion) else {
-        return BASE_POTION_COLOR;
-    };
-    let (mut r, mut g, mut b, mut total) = (0u32, 0u32, 0u32, 0u32);
-    for (e, _, amp) in def.effects {
-        let Some(e) = effect(e) else { continue };
-        let w = *amp as u32 + 1;
-        r += w * (e.color >> 16 & 255);
-        g += w * (e.color >> 8 & 255);
-        b += w * (e.color & 255);
-        total += w;
-    }
-    match (
-        r.checked_div(total),
-        g.checked_div(total),
-        b.checked_div(total),
-    ) {
-        (Some(r), Some(g), Some(b)) => (r << 16) | (g << 8) | b,
-        _ => BASE_POTION_COLOR,
-    }
-}

crates/horizon-client-core/src/registries.rs

@@ -28,10 +28,6 @@ pub struct Registries {
     /// Game rule name -> integer-valued.
     pub game_rules: Vec<(String, bool)>,
     pub players: Vec<String>,
-    /// `ClientSuggestionProvider.customCompletionSuggestions`: the extra chat
-    /// completions the server sent (ClientboundCustomChatCompletionsPacket),
-    /// each once.
-    pub custom_completions: std::collections::BTreeSet<String>,
     /// Scoreboard objective names, team names and tracked score holders.
     pub objectives: Vec<String>,
     pub teams: Vec<String>,
@@ -58,12 +54,6 @@ pub struct Registries {
     pub function_tags: Vec<String>,
     /// The block the source is looking at (relevant coordinates).
     pub target_block: Option<[i32; 3]>,
-    /// `ClientSuggestionProvider.getSelectedEntities`: the UUID of the
-    /// entity under the crosshair (`Entity.getStringUUID`), if any.
-    pub selected_entities: Vec<String>,
-    /// `ClientSuggestionProvider.getAbsoluteCoordinates`: the exact point of
-    /// that block hit, each coordinate as `%.2f` (`Locale.ROOT`).
-    pub target_point: Option<[String; 3]>,
     /// Every registry's element and tag ids (`minecraft:item` -> ...), as
     /// the server's registry access and reloadable registries hold them.
     pub by_registry: BTreeMap<String, RegistryIds>,
@@ -91,55 +81,7 @@ pub struct RegistryIds {
     pub tags: Vec<String>,
 }
 const EMPTY: &[String] = &[];
-/// ClientboundCustomChatCompletionsPacket.Action.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum CustomCompletionAction {
-    Add,
-    Remove,
-    Set,
-}
-impl CustomCompletionAction {
-    /// `Action.BY_ID`: `ByIdMap.continuous` with `OutOfBoundsStrategy.ZERO`,
-    /// so an unknown id is `ADD`.
-    pub fn from_id(id: i32) -> Self {
-        match id {
-            1 => Self::Remove,
-            2 => Self::Set,
-            _ => Self::Add,
-        }
-    }
-}
-/// `ClientSuggestionProvider.modifyCustomCompletions`: the server adds,
-/// removes or replaces the extra chat completions.
-pub fn modify_custom_completions(
-    set: &mut std::collections::BTreeSet<String>,
-    action: CustomCompletionAction,
-    entries: &[String],
-) {
-    match action {
-        CustomCompletionAction::Add => set.extend(entries.iter().cloned()),
-        CustomCompletionAction::Remove => {
-            for e in entries {
-                set.remove(e);
-            }
-        }
-        CustomCompletionAction::Set => {
-            set.clear();
-            set.extend(entries.iter().cloned());
-        }
-    }
-}
 impl Registries {
-    /// `ClientSuggestionProvider.getCustomTabSuggestions`: what chat (not a
-    /// command) completes, the online players' names with the server's custom
-    /// completions, each once.
-    pub fn custom_tab_suggestions(&self) -> std::collections::BTreeSet<&str> {
-        self.players
-            .iter()
-            .chain(&self.custom_completions)
-            .map(String::as_str)
-            .collect()
-    }
     /// Fill what the game did not build itself from vanilla's exported
     /// registries (`command-registries.json`, written by
     /// `VanillaCommandParseOracle registries`): built-in registries such as

crates/horizon-client-core/src/scoreboard.rs

@@ -112,7 +112,6 @@ pub fn style_from_json(v: &Value) -> Style {
                 .and_then(|h| u32::from_str_radix(h, 16).ok())
         });
     }
-    s.shadow_color = o.get("shadow_color").and_then(component::shadow_color);
     let flag = |k: &str| o.get(k).and_then(Value::as_bool);
     s.bold = flag("bold");
     s.italic = flag("italic");
@@ -663,22 +662,10 @@ pub fn name_shown(own: Option<&Team>, viewer: Option<&Team>, v: NameView) -> boo
     }
     !v.hud_hidden && !v.is_camera && visible && !v.is_vehicle
 }
-/// `ServerPlayer.die`: whether `other` hears the death message of `dying`
-/// (`broadcastSystemMessage`, `broadcastSystemToTeam` or
-/// `broadcastSystemToAllExceptTeam`, by the team's death message visibility).
-pub fn death_message_reaches(board: &Scoreboard, dying: &str, other: &str) -> bool {
-    let Some(team) = board.players_team(dying) else {
-        return true;
-    };
-    let same_team = board
-        .players_team(other)
-        .is_some_and(|t| t.name == team.name);
-    match team.death_message_visibility {
-        Visibility::Always => true,
-        Visibility::Never => false,
-        Visibility::HideForOtherTeams => same_team && other != dying,
-        Visibility::HideForOwnTeam => !same_team,
-    }
+/// `ServerPlayer.die`: whether a player's death message reaches the player
+/// themselves (the team broadcasts leave out the dying player).
+pub fn own_death_message_shown(team: Option<&Team>) -> bool {
+    team.is_none_or(|t| t.death_message_visibility == Visibility::Always)
 }
 
 // ---- objectives and scores ---------------------------------------------
@@ -1564,49 +1551,3 @@ mod tests {
         );
     }
 }
-
-/// `DamageSource.getLocalizedDeathMessage`: the cause's item with a custom
-/// name gets the `<id>.item` message, with the item's name as a third
-/// argument.
-pub fn death_message_args(
-    key: &str,
-    victim: &Text,
-    cause: &Text,
-    item: Option<&Text>,
-) -> (String, Vec<Text>) {
-    match item {
-        Some(item) => (
-            format!("{key}.item"),
-            vec![victim.clone(), cause.clone(), item.clone()],
-        ),
-        None => (key.to_owned(), vec![victim.clone(), cause.clone()]),
-    }
-}
-
-#[cfg(test)]
-mod death_message_tests {
-    use super::*;
-
-    #[test]
-    fn the_death_message_names_the_causes_item_when_it_has_a_custom_name() {
-        let victim = Text::literal("Steve");
-        let cause = Text::literal("Zombie");
-        // DamageSource.getLocalizedDeathMessage: the item variant, with the
-        // item's name as the third argument.
-        let (key, args) = death_message_args(
-            "death.attack.arrow",
-            &victim,
-            &cause,
-            Some(&Text::literal("My Sword")),
-        );
-        assert_eq!(key, "death.attack.arrow.item");
-        assert_eq!(args.len(), 3);
-        assert_eq!(args[0].plain(), "Steve");
-        assert_eq!(args[1].plain(), "Zombie");
-        assert_eq!(args[2].plain(), "My Sword");
-        // Without a custom name the message keeps its two arguments.
-        let (key, args) = death_message_args("death.attack.arrow", &victim, &cause, None);
-        assert_eq!(key, "death.attack.arrow");
-        assert_eq!(args.len(), 2);
-    }
-}

crates/horizon-client-core/src/text.rs

@@ -42,50 +42,17 @@ pub fn named_color(name: &str) -> Option<u32> {
 /// Click actions carried by locally constructed text components.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum ClickEvent {
-    /// `ClickEvent.OpenUrl`: an http or https link.
-    OpenUrl(String),
-    /// `ClickEvent.ChangePage`: a book's page, counted from 1.
-    ChangePage(i32),
     SuggestCommand(String),
-    /// `ClickEvent.RunCommand`: the command, with or without its `/`.
-    RunCommand(String),
     CopyToClipboard(String),
-    /// `ClickEvent.ShowDialog`: a `minecraft:dialog` registry id, or the
-    /// dialog itself as the component carried it.
-    ShowDialog(horizon_world::nbt::Tag),
     /// A local file to open with the system handler.
     /// Only allow this in locally constructed messages, never server/LAN text.
     OpenFile(String),
 }
 
-/// A non-character `minecraft:object` embedded in a text component.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum InlineObject {
-    Player {
-        profile: Value,
-        hat: bool,
-        fallback: String,
-    },
-    Atlas {
-        atlas: String,
-        sprite: String,
-        fallback: String,
-    },
-}
-impl InlineObject {
-    pub fn fallback(&self) -> &str {
-        match self {
-            Self::Player { fallback, .. } | Self::Atlas { fallback, .. } => fallback,
-        }
-    }
-}
-
 /// Text style; `None` fields inherit from the enclosing style.
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct Style {
     pub color: Option<u32>,
-    /// Text component `shadow_color` as packed ARGB. Zero suppresses shadows.
-    pub shadow_color: Option<u32>,
     pub bold: Option<bool>,
     pub italic: Option<bool>,
     pub underlined: Option<bool>,
@@ -94,17 +61,9 @@ pub struct Style {
     pub click: Option<ClickEvent>,
     /// Hover text.
     pub hover: Option<Box<Text>>,
-    /// `HoverEvent.ShowItem`: the event's `{id, count?, components?}` object.
-    pub hover_item: Option<Box<Value>>,
-    /// `HoverEvent.ShowEntity`: the event's `{id, uuid, name?}` object.
-    pub hover_entity: Option<Box<Value>>,
-    /// `Style.insertion`: the text a Shift-click puts in the chat box.
-    pub insertion: Option<String>,
     /// The font (`FontDescription.Resource`), a full id like
     /// `minecraft:alt`; the default font when unset.
     pub font: Option<String>,
-    /// Content metadata for a single U+FFFC object span; never inherited.
-    pub inline_object: Option<InlineObject>,
 }
 /// A style's `font` field: an identifier (`alt` is `minecraft:alt`).
 pub fn font_id(v: &Value) -> Option<String> {
@@ -120,7 +79,6 @@ impl Style {
     /// Fill unset fields from `base` (Style.applyTo).
     pub fn inherit(&mut self, base: &Style) {
         self.color = self.color.or(base.color);
-        self.shadow_color = self.shadow_color.or(base.shadow_color);
         self.bold = self.bold.or(base.bold);
         self.italic = self.italic.or(base.italic);
         self.underlined = self.underlined.or(base.underlined);
@@ -129,15 +87,8 @@ impl Style {
         if self.click.is_none() {
             self.click.clone_from(&base.click);
         }
-        // One HoverEvent: its three kinds are inherited together, so a style
-        // with its own event never picks up another kind from `base`.
-        if self.hover.is_none() && self.hover_item.is_none() && self.hover_entity.is_none() {
+        if self.hover.is_none() {
             self.hover.clone_from(&base.hover);
-            self.hover_item.clone_from(&base.hover_item);
-            self.hover_entity.clone_from(&base.hover_entity);
-        }
-        if self.insertion.is_none() {
-            self.insertion.clone_from(&base.insertion);
         }
         if self.font.is_none() {
             self.font.clone_from(&base.font);
@@ -367,13 +318,7 @@ impl Text {
     }
     /// Component.getString: the plain characters.
     pub fn plain(&self) -> String {
-        self.spans
-            .iter()
-            .map(|s| match &s.style.inline_object {
-                Some(object) if s.text == "\u{fffc}" => object.fallback(),
-                _ => s.text.as_str(),
-            })
-            .collect()
+        self.spans.iter().map(|s| s.text.as_str()).collect()
     }
     pub fn is_empty(&self) -> bool {
         self.spans.iter().all(|s| s.text.is_empty())
@@ -439,7 +384,31 @@ impl Text {
                     continue;
                 }
                 let Some(code) = chars.next() else { break };
-                let next = legacy_format(&style, code, &span.style);
+                let code = code.to_ascii_lowercase();
+                let next = if let Some(c) = COLORS.iter().find(|c| c.0 == code) {
+                    // Style.applyLegacyFormat: a colour clears the decorations.
+                    Style {
+                        color: Some(c.2),
+                        bold: Some(false),
+                        italic: Some(false),
+                        underlined: Some(false),
+                        strikethrough: Some(false),
+                        obfuscated: Some(false),
+                        ..style.clone()
+                    }
+                } else {
+                    let mut s = style.clone();
+                    match code {
+                        'k' => s.obfuscated = Some(true),
+                        'l' => s.bold = Some(true),
+                        'm' => s.strikethrough = Some(true),
+                        'n' => s.underlined = Some(true),
+                        'o' => s.italic = Some(true),
+                        'r' => s = span.style.clone(),
+                        _ => {}
+                    }
+                    s
+                };
                 if next != style {
                     if !current.is_empty() {
                         out.spans.push(Span {
@@ -526,9 +495,8 @@ impl Text {
 }
 
 /// The style fields of a component's JSON.
-const STYLE_KEYS: [&str; 11] = [
+const STYLE_KEYS: [&str; 9] = [
     "color",
-    "shadow_color",
     "bold",
     "italic",
     "underlined",
@@ -536,7 +504,6 @@ const STYLE_KEYS: [&str; 11] = [
     "obfuscated",
     "click_event",
     "hover_event",
-    "insertion",
     "font",
 ];
 /// Style.Serializer: the fields a style sets.
@@ -549,9 +516,6 @@ fn style_json(style: &Style) -> Vec<(String, Value)> {
             .map_or_else(|| format!("#{c:06X}"), |n| n.1.to_owned());
         out.push(("color".to_owned(), name.into()));
     }
-    if let Some(shadow) = style.shadow_color {
-        out.push(("shadow_color".to_owned(), Value::from(shadow as i32)));
-    }
     for (key, flag) in [
         ("bold", style.bold),
         ("italic", style.italic),
@@ -565,22 +529,12 @@ fn style_json(style: &Style) -> Vec<(String, Value)> {
     }
     if let Some(click) = &style.click {
         let event = match click {
-            ClickEvent::OpenUrl(url) => json!({ "action": "open_url", "url": url }),
-            ClickEvent::ChangePage(page) => json!({ "action": "change_page", "page": page }),
             ClickEvent::SuggestCommand(command) => {
                 json!({ "action": "suggest_command", "command": command })
             }
             ClickEvent::CopyToClipboard(value) => {
                 json!({ "action": "copy_to_clipboard", "value": value })
             }
-            ClickEvent::RunCommand(command) => {
-                json!({ "action": "run_command", "command": command })
-            }
-            // ClickEvent.ShowDialog.CODEC: the dialog the server sent it with.
-            ClickEvent::ShowDialog(dialog) => json!({
-                "action": "show_dialog",
-                "dialog": crate::scoreboard::tag_to_json(dialog),
-            }),
             ClickEvent::OpenFile(path) => json!({ "action": "open_file", "path": path }),
         };
         out.push(("click_event".to_owned(), event));
@@ -590,17 +544,6 @@ fn style_json(style: &Style) -> Vec<(String, Value)> {
             "hover_event".to_owned(),
             json!({ "action": "show_text", "value": hover.component() }),
         ));
-    } else if let Some(Value::Object(item)) = style.hover_item.as_deref() {
-        let mut event = item.clone();
-        event.insert("action".into(), "show_item".into());
-        out.push(("hover_event".to_owned(), Value::Object(event)));
-    } else if let Some(Value::Object(entity)) = style.hover_entity.as_deref() {
-        let mut event = entity.clone();
-        event.insert("action".into(), "show_entity".into());
-        out.push(("hover_event".to_owned(), Value::Object(event)));
-    }
-    if let Some(insertion) = &style.insertion {
-        out.push(("insertion".to_owned(), insertion.clone().into()));
     }
     if let Some(font) = &style.font {
         out.push(("font".to_owned(), font.clone().into()));
@@ -608,35 +551,6 @@ fn style_json(style: &Style) -> Vec<(String, Value)> {
     out
 }
 
-/// `Style.applyLegacyFormat` for the code after a `§`, `§r` going back to
-/// `reset` (`StringDecomposer.iterateFormatted`); an unknown code changes nothing.
-pub fn legacy_format(style: &Style, code: char, reset: &Style) -> Style {
-    let code = code.to_ascii_lowercase();
-    if let Some(c) = COLORS.iter().find(|c| c.0 == code) {
-        // A colour clears the decorations.
-        return Style {
-            color: Some(c.2),
-            bold: Some(false),
-            italic: Some(false),
-            underlined: Some(false),
-            strikethrough: Some(false),
-            obfuscated: Some(false),
-            ..style.clone()
-        };
-    }
-    let mut s = style.clone();
-    match code {
-        'k' => s.obfuscated = Some(true),
-        'l' => s.bold = Some(true),
-        'm' => s.strikethrough = Some(true),
-        'n' => s.underlined = Some(true),
-        'o' => s.italic = Some(true),
-        'r' => s = reset.clone(),
-        _ => {}
-    }
-    s
-}
-
 /// TranslatableContents.decomposeTemplate: `%s` takes the next argument,
 /// `%n$s` a numbered one and `%%` is a percent sign. Malformed templates are
 /// shown verbatim.

crates/horizon-client-core/src/who.rs

@@ -1,8 +0,0 @@
-//! Who an action came from or is aimed at: the player or a mob by id.
-
-/// Who caused damage or is being targeted.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub enum Who {
-    Player,
-    Mob(u32),
-}

crates/horizon-client-input/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "horizon-client-input"
-version = "0.1.0"
-edition.workspace = true
-license.workspace = true
-rust-version = "1.90"
-description = "The client's input layer: key bindings and their names, mouse, controllers, clipboard and window options"
-
-[dependencies]
-horizon-client-core = { path = "../horizon-client-core" }
-winit = "0.30.13"
-# The window icon.
-horizon-theme = { path = "../horizon-theme" }
-png = "0.18"
-arboard = { version = "3.6.1", default-features = false, features = ["wayland-data-control"] }
-# The DualSense's trigger effects (the `controllers` feature).
-horizon-dualsense = { path = "../horizon-dualsense", optional = true }
-
-[features]
-controllers = ["dep:horizon-dualsense"]
-
-[lints]
-workspace = true

crates/horizon-client-input/src/lib.rs

@@ -1,14 +0,0 @@
-//! The client's input layer, below gameplay and screens: key bindings and their
-//! names, toggle keys, mouse settings, controllers, the clipboard and window
-//! options. horizon-client re-exports each module under its old path
-//! (`horizon_client::keybinds`, ...).
-#![forbid(unsafe_code)]
-pub mod clipboard;
-pub mod gamepad;
-pub mod input;
-pub mod interaction_input;
-pub mod key_names;
-pub mod keybinds;
-pub mod keymapping;
-pub mod mouse;
-pub mod window;

crates/horizon-client-render/Cargo.toml

@@ -1,67 +0,0 @@
-[package]
-name = "horizon-client-render"
-version = "0.1.0"
-edition.workspace = true
-license.workspace = true
-rust-version = "1.90"
-description = "The client's world data, rendering and screens: chunks, meshing, light, streaming, the renderer, the HUD, menus and settings; no gameplay"
-
-[dependencies]
-horizon-assets = { path = "../horizon-assets" }
-horizon-bench = { path = "../horizon-bench" }
-horizon-client-core = { path = "../horizon-client-core" }
-horizon-client-input = { path = "../horizon-client-input" }
-horizon-command = { path = "../horizon-command" }
-horizon-core = { path = "../horizon-core" }
-horizon-hdr = { path = "../horizon-hdr" }
-horizon-items = { path = "../horizon-items" }
-horizon-protocol = { path = "../horizon-protocol" }
-horizon-shader-api = { path = "../horizon-shader-api" }
-horizon-shaders = { path = "../horizon-shaders" }
-horizon-telemetry = { path = "../horizon-telemetry", default-features = false, features = ["live"] }
-horizon-theme = { path = "../horizon-theme" }
-horizon-threads = { path = "../horizon-threads" }
-horizon-world = { path = "../horizon-world" }
-ab_glyph = "0.2.32"
-bytemuck = { version = "1.24", features = ["derive"] }
-# Sound (ALSA on Linux); the `audio` feature.
-cpal = { version = "0.16", optional = true }
-chrono = { version = "0.4.42", default-features = false, features = ["clock", "std"] }
-flate2 = { version = "1.1.10", default-features = false, features = ["zlib-rs", "runtime_detection"] }
-glam = "0.30"
-log = "0.4"
-miniz_oxide = "0.8"
-naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out"] }
-png = "0.18"
-pollster = "0.4"
-serde = { version = "1", features = ["derive"] }
-serde_json = { version = "1.0.151", features = ["raw_value"] }
-sha2 = "0.10.9"
-symphonia = { version = "0.5", default-features = false, features = ["ogg", "vorbis"] }
-unicode-bidi = "0.3.18"
-ureq = { version = "2", default-features = false, features = ["tls"] }
-wgpu = { version = "30.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "metal", "wgsl", "naga-ir"] }
-winit = "0.30.13"
-zip = { version = "2", default-features = false, features = ["deflate"] }
-
-[target.'cfg(unix)'.dependencies]
-rustix = { version = "1", default-features = false, features = ["std", "time"] }
-
-[target.'cfg(windows)'.dependencies]
-wgpu = { version = "30.0.1", default-features = false, features = ["dx12"] }
-
-[target.'cfg(not(target_os = "macos"))'.dependencies]
-wgpu = { version = "30.0.1", default-features = false, features = ["gles"] }
-
-[features]
-# Sound output: horizon-client's `audio` feature.
-audio = ["dep:cpal"]
-# Helpers horizon-client's tests build their fixtures with.
-test-support = []
-
-[lints]
-workspace = true
-
-[dev-dependencies]
-horizon-items = { path = "../horizon-items", features = ["test-support"] }
-naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out", "msl-out", "spv-out"] }

crates/horizon-client-render/examples/compositor.rs

@@ -1,151 +0,0 @@
-//! Two offscreen frames presented in one window, without game resources or player data.
-//! `cargo run --profile fast -p horizon-client-render --example compositor -- --smoke`
-use horizon_client_render::gfx::compositor::Compositor;
-use std::sync::Arc;
-use winit::{
-    application::ApplicationHandler,
-    event::WindowEvent,
-    event_loop::{ActiveEventLoop, EventLoop},
-    window::{Window, WindowId},
-};
-
-struct Frames {
-    window: Arc<Window>,
-    compositor: Compositor,
-    textures: [wgpu::Texture; 2],
-}
-
-impl Frames {
-    fn new(event_loop: &ActiveEventLoop) -> horizon_client_render::Result<Self> {
-        let window = Arc::new(
-            event_loop.create_window(
-                Window::default_attributes()
-                    .with_title("Compositor: red and blue views")
-                    .with_inner_size(winit::dpi::PhysicalSize::new(640, 360)),
-            )?,
-        );
-        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_with_display_handle(
-            Box::new(window.clone()),
-        ));
-        let surface = instance.create_surface(window.clone())?;
-        let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
-            compatible_surface: Some(&surface),
-            ..Default::default()
-        }))?;
-        let (device, queue) = pollster::block_on(adapter.request_device(&Default::default()))?;
-        let textures = [[0, 0, 255, 255], [255, 0, 0, 255]].map(|pixel| {
-            let size = wgpu::Extent3d {
-                width: 320,
-                height: 360,
-                depth_or_array_layers: 1,
-            };
-            let texture = device.create_texture(&wgpu::TextureDescriptor {
-                label: Some("Offscreen view"),
-                size,
-                mip_level_count: 1,
-                sample_count: 1,
-                dimension: wgpu::TextureDimension::D2,
-                format: wgpu::TextureFormat::Bgra8Unorm,
-                usage: wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::COPY_DST,
-                view_formats: &[],
-            });
-            queue.write_texture(
-                texture.as_image_copy(),
-                &pixel.repeat(320 * 360),
-                wgpu::TexelCopyBufferLayout {
-                    offset: 0,
-                    bytes_per_row: Some(320 * 4),
-                    rows_per_image: Some(360),
-                },
-                size,
-            );
-            texture
-        });
-        let compositor = Compositor::new(
-            surface,
-            &adapter,
-            &device,
-            &queue,
-            window.inner_size().into(),
-        )?;
-        Ok(Self {
-            window,
-            compositor,
-            textures,
-        })
-    }
-}
-
-#[derive(Default)]
-struct Demo {
-    frames: Option<Frames>,
-    error: Option<String>,
-    presented: usize,
-    smoke: bool,
-}
-
-impl ApplicationHandler for Demo {
-    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
-        if self.frames.is_none() {
-            match Frames::new(event_loop) {
-                Ok(frames) => self.frames = Some(frames),
-                Err(error) => {
-                    self.error = Some(error.to_string());
-                    event_loop.exit();
-                }
-            }
-        }
-    }
-
-    fn window_event(&mut self, event_loop: &ActiveEventLoop, _: WindowId, event: WindowEvent) {
-        let Some(f) = &mut self.frames else { return };
-        match event {
-            WindowEvent::CloseRequested => event_loop.exit(),
-            WindowEvent::Resized(size) => f.compositor.resize(size.width, size.height),
-            // Uncovered pixels are black; resize smaller to exercise clipping.
-            WindowEvent::RedrawRequested
-                if f.compositor
-                    .present(&[(&f.textures[0], [0, 0]), (&f.textures[1], [320, 0])]) =>
-            {
-                self.presented += 1;
-                if self.smoke && self.presented == 10 {
-                    f.compositor.set_vsync(false);
-                    f.compositor.resize(0, 0);
-                    assert!(!f.compositor.present(&[]));
-                    f.compositor.resize(u32::MAX, u32::MAX);
-                    assert!(!f.compositor.present(&[]));
-                    f.compositor.resize(400, 240);
-                    let _ = f
-                        .window
-                        .request_inner_size(winit::dpi::PhysicalSize::new(400, 240));
-                }
-                if self.smoke && self.presented == 20 {
-                    println!("compositor: 20 frames, resize, suspension and clipping passed");
-                    event_loop.exit();
-                }
-            }
-            _ => {}
-        }
-    }
-
-    fn about_to_wait(&mut self, _: &ActiveEventLoop) {
-        if let Some(f) = &self.frames {
-            f.window.request_redraw();
-        }
-    }
-}
-
-fn main() -> horizon_client_render::Result<()> {
-    let mut demo = Demo {
-        smoke: std::env::args().any(|a| a == "--smoke"),
-        ..Default::default()
-    };
-    EventLoop::new()?.run_app(&mut demo)?;
-    if let Some(error) = demo.error {
-        return Err(error.into());
-    }
-    if demo.smoke && demo.presented < 20 {
-        return Err("smoke test closed early".into());
-    }
-    Ok(())
-}

crates/horizon-client-render/src/bidi.rs

@@ -1,302 +0,0 @@
-//! Right-to-left text (`FormattedBidiReorder.reorder`, behind
-//! `Language.getVisualOrder`): the logical text a player types becomes the
-//! glyphs a font draws left to right. Arabic letters are shaped into their
-//! joined presentation forms (ICU's `ArabicShaping` with `LETTERS_SHAPE`), the
-//! text is reordered by the Unicode bidirectional algorithm, and characters in
-//! right-to-left runs are mirrored. Left-to-right text comes back unchanged.
-use crate::text::{Span, Text};
-use std::borrow::Cow;
-use unicode_bidi::{
-    BidiClass, Direction, Level, ParagraphBidiInfo, bidi_class, get_base_direction,
-};
-
-/// How a letter joins its neighbours, as ICU's shaper sees it: `Right` joins
-/// the letter before it only, `Dual` both neighbours, `Mark` is skipped over
-/// (diacritics) and `None` never joins.
-#[derive(Clone, Copy, PartialEq)]
-enum Join {
-    None,
-    Right,
-    Dual,
-    Mark,
-}
-use Join::{Dual, Mark, Right};
-
-/// ICU's joining table (`araLink`): code point ranges and their class, with the
-/// lam-alef ligatures at the end. Anything else is `Join::None`.
-const JOINS: &[(u32, u32, Join)] = &[
-    (0x0622, 0x0625, Right),
-    (0x0626, 0x0626, Dual),
-    (0x0627, 0x0627, Right),
-    (0x0628, 0x0628, Dual),
-    (0x0629, 0x0629, Right),
-    (0x062A, 0x062E, Dual),
-    (0x062F, 0x0632, Right),
-    (0x0633, 0x063A, Dual),
-    (0x0640, 0x0647, Dual),
-    (0x0648, 0x0649, Right),
-    (0x064A, 0x064A, Dual),
-    (0x064B, 0x0656, Mark),
-    (0x0670, 0x0670, Mark),
-    (0x0671, 0x0673, Right),
-    (0x0675, 0x0677, Right),
-    (0x0678, 0x0687, Dual),
-    (0x0688, 0x0699, Right),
-    (0x069A, 0x06B9, Dual),
-    (0x06BA, 0x06BA, Right),
-    (0x06BB, 0x06BF, Dual),
-    (0x06C0, 0x06C0, Right),
-    (0x06C1, 0x06C1, Dual),
-    (0x06C2, 0x06CB, Right),
-    (0x06CC, 0x06CC, Dual),
-    (0x06CD, 0x06CD, Right),
-    (0x06CE, 0x06D1, Dual),
-    (0x06D2, 0x06D3, Right),
-    (0x200D, 0x200D, Dual),
-    (0x206D, 0x206F, Mark),
-    (0xFEF5, 0xFEFC, Right),
-];
-
-/// Letters that have joined forms and the code point of the isolated one; the
-/// final, initial and medial forms follow it (a right-joining letter has the
-/// isolated and final only). The lam-alef ligatures are their own letters.
-/// ICU leaves the extended letters (پ چ ژ ک گ ی and the rest of U+0679 to
-/// U+06D3) unchanged, so they are in `JOINS` but not here.
-#[rustfmt::skip]
-const FORMS: &[(u32, u32)] = &[
-    (0x0622, 0xFE81), (0x0623, 0xFE83), (0x0624, 0xFE85), (0x0625, 0xFE87), (0x0626, 0xFE89),
-    (0x0627, 0xFE8D), (0x0628, 0xFE8F), (0x0629, 0xFE93), (0x062A, 0xFE95), (0x062B, 0xFE99),
-    (0x062C, 0xFE9D), (0x062D, 0xFEA1), (0x062E, 0xFEA5), (0x062F, 0xFEA9), (0x0630, 0xFEAB),
-    (0x0631, 0xFEAD), (0x0632, 0xFEAF), (0x0633, 0xFEB1), (0x0634, 0xFEB5), (0x0635, 0xFEB9),
-    (0x0636, 0xFEBD), (0x0637, 0xFEC1), (0x0638, 0xFEC5), (0x0639, 0xFEC9), (0x063A, 0xFECD),
-    (0x0641, 0xFED1), (0x0642, 0xFED5), (0x0643, 0xFED9), (0x0644, 0xFEDD), (0x0645, 0xFEE1),
-    (0x0646, 0xFEE5), (0x0647, 0xFEE9), (0x0648, 0xFEED), (0x0649, 0xFEEF), (0x064A, 0xFEF1),
-    (0xFEF5, 0xFEF5), (0xFEF7, 0xFEF7), (0xFEF9, 0xFEF9), (0xFEFB, 0xFEFB),
-];
-
-/// `Bidi_Mirroring_Glyph` (`UCharacter.getMirror`): each pair is two
-/// neighbouring characters that mirror each other.
-const MIRRORED: &str = "\
-        ()<>[]{}«»༺༻༼༽᚛᚜‹›⁅⁆⁽⁾₍₎∈∋∉∌∊∍∕⧵∟⯾∠⦣∡⦛∢⦠∤⫮∼∽≃⋍≅≌≒≓\
-        ≔≕≤≥≦≧≨≩≪≫≮≯≰≱≲≳≴≵≶≷≸≹≺≻≼≽≾≿⊀⊁⊂⊃⊄⊅⊆⊇⊈⊉⊊⊋⊏⊐⊑⊒⊘⦸⊢⊣⊦⫞\
-        ⊨⫤⊩⫣⊫⫥⊰⊱⊲⊳⊴⊵⊶⊷⊸⟜⋉⋊⋋⋌⋐⋑⋖⋗⋘⋙⋚⋛⋜⋝⋞⋟⋠⋡⋢⋣⋤⋥⋦⋧⋨⋩⋪⋫⋬⋭⋰⋱⋲⋺\
-        ⋳⋻⋴⋼⋶⋽⋷⋾⌈⌉⌊⌋〈〉❨❩❪❫❬❭❮❯❰❱❲❳❴❵⟃⟄⟅⟆⟈⟉⟋⟍⟕⟖⟝⟞⟢⟣⟤⟥⟦⟧⟨⟩⟪⟫\
-        ⟬⟭⟮⟯⦃⦄⦅⦆⦇⦈⦉⦊⦋⦌⦍⦐⦎⦏⦑⦒⦓⦔⦕⦖⦗⦘⦤⦥⦨⦩⦪⦫⦬⦭⦮⦯⧀⧁⧄⧅⧏⧐⧑⧒⧔⧕⧘⧙⧚⧛\
-        ⧨⧩⧸⧹⧼⧽⨫⨬⨭⨮⨴⨵⨼⨽⩤⩥⩹⩺⩻⩼⩽⩾⩿⪀⪁⪂⪃⪄⪅⪆⪇⪈⪉⪊⪋⪌⪍⪎⪏⪐⪑⪒⪓⪔⪕⪖⪗⪘⪙⪚\
-        ⪛⪜⪝⪞⪟⪠⪡⪢⪦⪧⪨⪩⪪⪫⪬⪭⪯⪰⪱⪲⪳⪴⪵⪶⪷⪸⪹⪺⪻⪼⪽⪾⪿⫀⫁⫂⫃⫄⫅⫆⫇⫈⫉⫊⫋⫌⫍⫎⫏⫐\
-        ⫑⫒⫓⫔⫕⫖⫬⫭⫷⫸⫹⫺⸂⸃⸄⸅⸉⸊⸌⸍⸜⸝⸠⸡⸢⸣⸤⸥⸦⸧⸨⸩⹕⹖⹗⹘⹙⹚⹛⹜〈〉《》「」『』【】\
-        〔〕〖〗〘〙〚〛﹙﹚﹛﹜﹝﹞﹤﹥（）＜＞［］｛｝｟｠｢｣";
-
-fn join(c: char) -> Join {
-    let c = c as u32;
-    JOINS
-        .iter()
-        .find(|&&(from, to, _)| (from..=to).contains(&c))
-        .map_or(Join::None, |&(_, _, join)| join)
-}
-
-/// The letter whose joined form `c` is (ICU shapes the forms again), or `c`.
-fn letter_of(c: char) -> char {
-    let c32 = c as u32;
-    if !matches!(c32, 0xFE70..=0xFEFC) {
-        return c;
-    }
-    if (0xFE70..0xFE80).contains(&c32) {
-        // The diacritics' forms pair up from fathatan on.
-        return char::from_u32(0x064B + (c32 - 0xFE70) / 2).unwrap_or(c);
-    }
-    FORMS
-        .iter()
-        .find(|&&(letter, iso)| {
-            let forms = if join(char::from_u32(letter).unwrap_or(c)) == Dual {
-                4
-            } else {
-                2
-            };
-            (iso..iso + forms).contains(&c32)
-        })
-        .and_then(|&(letter, _)| char::from_u32(letter))
-        .unwrap_or(c)
-}
-
-/// `ArabicShaping(LETTERS_SHAPE).shape`: lam followed by an alef (diacritics
-/// may sit between) becomes one ligature, then every letter takes the isolated,
-/// final, initial or medial form its neighbours call for. Diacritics take the
-/// tatweel form between two joined letters. The text can only get shorter.
-fn shape(text: &[char]) -> Vec<char> {
-    let letters: Vec<char> = text.iter().map(|&c| letter_of(c)).collect();
-    let mut chars = Vec::with_capacity(letters.len());
-    let mut i = 0;
-    while i < letters.len() {
-        if letters[i] == '\u{644}' {
-            let mut at = i + 1;
-            while letters.get(at).is_some_and(|&c| join(c) == Mark) {
-                at += 1;
-            }
-            let alef = letters.get(at).and_then(|&c| {
-                ['\u{622}', '\u{623}', '\u{625}', '\u{627}']
-                    .iter()
-                    .position(|&a| a == c)
-            });
-            if let Some(alef) = alef {
-                chars.push(char::from_u32(0xFEF5 + 2 * alef as u32).unwrap_or('\u{644}'));
-                chars.extend_from_slice(&letters[i + 1..at]);
-                i = at + 1;
-                continue;
-            }
-        }
-        chars.push(letters[i]);
-        i += 1;
-    }
-    // Whether the nearest letter before joins the next one, and the joins of
-    // the nearest letter after.
-    let mut joins_next = false;
-    let mut out = Vec::with_capacity(chars.len());
-    for (i, &c) in chars.iter().enumerate() {
-        let next_joins = chars[i + 1..]
-            .iter()
-            .map(|&n| join(n))
-            .find(|&j| j != Mark)
-            .is_some_and(|j| j != Join::None);
-        let kind = join(c);
-        let shaped = match kind {
-            Join::None => {
-                joins_next = false;
-                c
-            }
-            Mark => match c as u32 {
-                m @ 0x064B..=0x0652 => {
-                    let iso = 0xFE70 + 2 * (m - 0x064B);
-                    let tatweel = joins_next && next_joins && !matches!(m, 0x064C | 0x064D);
-                    char::from_u32(iso + u32::from(tatweel)).unwrap_or(c)
-                }
-                _ => c,
-            },
-            Right | Dual => {
-                let to_next = kind == Dual && next_joins;
-                let form = match (joins_next, to_next) {
-                    (false, false) => 0,
-                    (true, false) => 1,
-                    (false, true) => 2,
-                    (true, true) => 3,
-                };
-                joins_next = kind == Dual;
-                FORMS
-                    .binary_search_by_key(&(c as u32), |&(letter, _)| letter)
-                    .ok()
-                    .and_then(|at| char::from_u32(FORMS[at].1 + form))
-                    .unwrap_or(c)
-            }
-        };
-        out.push(shaped);
-    }
-    out
-}
-
-/// `UCharacter.getMirror`.
-fn mirror(c: char) -> char {
-    if bidi_class(c) != BidiClass::ON {
-        return c;
-    }
-    let mut pairs = MIRRORED.chars();
-    while let (Some(a), Some(b)) = (pairs.next(), pairs.next()) {
-        if c == a {
-            return b;
-        }
-        if c == b {
-            return a;
-        }
-    }
-    c
-}
-
-/// Whether a character can change anything: right-to-left letters and numbers,
-/// the explicit direction controls and the diacritics that shaping turns into
-/// letters. Without any, left-to-right text keeps its order.
-fn directional(c: char) -> bool {
-    c as u32 >= 0x0590
-        && (matches!(c as u32, 0x064B..=0x0652)
-            || matches!(
-                bidi_class(c),
-                BidiClass::R
-                    | BidiClass::AL
-                    | BidiClass::AN
-                    | BidiClass::LRE
-                    | BidiClass::RLE
-                    | BidiClass::LRO
-                    | BidiClass::RLO
-                    | BidiClass::PDF
-                    | BidiClass::LRI
-                    | BidiClass::RLI
-                    | BidiClass::FSI
-                    | BidiClass::PDI
-            ))
-}
-
-/// Whether `chars` keep their order and shapes: left-to-right text without
-/// anything directional, in a language that reads left to right by default.
-fn unchanged(mut chars: impl Iterator<Item = char>, default_rtl: bool) -> bool {
-    !default_rtl && !chars.any(directional)
-}
-
-/// `FormattedBidiReorder.reorder`: `chars` shaped, in visual order, with each
-/// character's position in the shaped text. A character's style is the one at
-/// its position in the shaped text, as `SubStringSource` takes it (the text
-/// shrinks at a lam-alef ligature).
-fn reorder(chars: &[char], default_rtl: bool) -> Vec<(char, usize)> {
-    let shaped = shape(chars);
-    let plain: String = shaped.iter().collect();
-    // DEFAULT_RTL only changes text without a strong character.
-    let level =
-        (default_rtl && get_base_direction(plain.as_str()) == Direction::Mixed).then(Level::rtl);
-    let info = ParagraphBidiInfo::new(&plain, level);
-    let levels = info.reordered_levels_per_char(0..plain.len());
-    ParagraphBidiInfo::reorder_visual(&levels)
-        .into_iter()
-        .map(|i| {
-            let c = if levels[i].is_rtl() {
-                mirror(shaped[i])
-            } else {
-                shaped[i]
-            };
-            (c, i)
-        })
-        .collect()
-}
-
-/// `Language.getVisualOrder` of a text (its `§` codes already resolved), for
-/// the current language's direction.
-pub fn visual(text: &Text) -> Cow<'_, Text> {
-    let default_rtl = crate::lang::bidirectional();
-    if unchanged(text.chars().map(|(c, _)| c), default_rtl) {
-        return Cow::Borrowed(text);
-    }
-    let chars: Vec<char> = text.chars().map(|(c, _)| c).collect();
-    let styles: Vec<_> = text.chars().map(|(_, style)| style).collect();
-    let mut out = Text::default();
-    for (c, at) in reorder(&chars, default_rtl) {
-        match out.spans.last_mut() {
-            Some(span) if span.style == *styles[at] => span.text.push(c),
-            _ => out.spans.push(Span {
-                text: c.to_string(),
-                style: styles[at].clone(),
-            }),
-        }
-    }
-    Cow::Owned(out)
-}
-
-/// The same for a plain string.
-pub fn visual_str(s: &str) -> Cow<'_, str> {
-    let default_rtl = crate::lang::bidirectional();
-    if unchanged(s.chars(), default_rtl) {
-        return Cow::Borrowed(s);
-    }
-    let chars: Vec<char> = s.chars().collect();
-    Cow::Owned(
-        reorder(&chars, default_rtl)
-            .into_iter()
-            .map(|(c, _)| c)
-            .collect(),
-    )
-}

crates/horizon-client-render/src/biome.rs

@@ -1,569 +0,0 @@
-//! Biome colours from the pinned biome definitions and colormaps
-//! (`Biome.getGrassColor`/`getFoliageColor`/..., `BlockTintSources`).
-use crate::Result;
-use horizon_core::{noise::SimplexNoise, position::BlockPos, random::LegacyRandom};
-use serde_json::Value;
-use std::{
-    collections::{BTreeMap, HashMap},
-    fs,
-    path::Path,
-    sync::Arc,
-};
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum GrassModifier {
-    None,
-    DarkForest,
-    Swamp,
-}
-#[derive(Clone, Debug)]
-pub struct SpawnEntry {
-    pub entity: String,
-    pub weight: u32,
-    pub min: u32,
-    pub max: u32,
-    /// A `ConstantInt` count (sampling draws nothing).
-    pub constant: bool,
-}
-/// A `natural_mob_spawns` / `spawn_overrides` entry list.
-pub fn parse_entries(list: &Value) -> Vec<SpawnEntry> {
-    list.as_array()
-        .into_iter()
-        .flatten()
-        .filter_map(|e| {
-            let count = &e["count"];
-            let (min, max, constant) = match count {
-                Value::Number(n) => {
-                    let n = n.as_u64().unwrap_or(1) as u32;
-                    (n, n, true)
-                }
-                c if c["type"].as_str() == Some("minecraft:constant") => {
-                    let n = c["value"].as_u64().unwrap_or(1) as u32;
-                    (n, n, true)
-                }
-                c => (
-                    c["min_inclusive"].as_u64().unwrap_or(1) as u32,
-                    c["max_inclusive"].as_u64().unwrap_or(1) as u32,
-                    false,
-                ),
-            };
-            Some(SpawnEntry {
-                entity: e["type"].as_str()?.to_owned(),
-                weight: e["weight"].as_u64().unwrap_or(1) as u32,
-                min,
-                max,
-                constant,
-            })
-        })
-        .collect()
-}
-/// `MobSpawnSettings.MobSpawnCost`.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct SpawnCost {
-    pub energy_budget: f64,
-    pub charge: f64,
-}
-/// The `spawn_costs` of a `natural_mob_spawns` value.
-pub fn parse_costs(costs: &Value) -> HashMap<String, SpawnCost> {
-    costs
-        .as_object()
-        .into_iter()
-        .flatten()
-        .map(|(k, c)| {
-            (
-                k.clone(),
-                SpawnCost {
-                    energy_budget: c["energy_budget"].as_f64().unwrap_or(0.0),
-                    charge: c["charge"].as_f64().unwrap_or(0.0),
-                },
-            )
-        })
-        .collect()
-}
-
-#[derive(Clone, Debug)]
-pub struct BiomeInfo {
-    /// `natural_mob_spawns` by category (creature, monster, ...).
-    pub spawns: HashMap<String, Vec<SpawnEntry>>,
-    /// `natural_mob_spawns` spawn costs by entity type.
-    pub spawn_costs: HashMap<String, SpawnCost>,
-    /// The `gameplay/creature_world_gen_spawn_probability` attribute.
-    pub creature_probability: f32,
-    /// The `gameplay/increased_fire_burnout` attribute (jungles, swamps, peaks,
-    /// mushroom fields).
-    pub increased_fire_burnout: bool,
-    pub name: String,
-    pub temperature: f32,
-    /// `temperature_modifier: frozen` (the frozen oceans).
-    pub frozen: bool,
-    pub downfall: f32,
-    pub precipitation: bool,
-    pub grass: u32,
-    pub modifier: GrassModifier,
-    pub foliage: u32,
-    pub dry_foliage: u32,
-    pub water: u32,
-    pub sky: Option<u32>,
-    /// The biome's own fog colour attribute; otherwise the dimension's applies.
-    pub fog: Option<u32>,
-    pub water_fog: u32,
-    /// `BiomeGenerationSettings.features`: the placed feature ids of each
-    /// `GenerationStep.Decoration` step, in order.
-    pub features: Vec<Vec<String>>,
-}
-impl BiomeInfo {
-    /// `Biome.getHeightAdjustedTemperature`: the frozen modifier, then cooler
-    /// with height above `sea_level + 17`.
-    pub fn temperature_at(&self, pos: BlockPos, sea_level: i32) -> f32 {
-        use horizon_world::worldgen::biome_temperature::{
-            BiomeTemperatureSettings, TemperatureModifier,
-        };
-        BiomeTemperatureSettings {
-            base_temperature: self.temperature,
-            modifier: if self.frozen {
-                TemperatureModifier::Frozen
-            } else {
-                TemperatureModifier::None
-            },
-            has_precipitation: self.precipitation,
-            downfall: self.downfall,
-        }
-        .height_adjusted(pos, sea_level)
-    }
-    /// `Biome.getPrecipitationAt` in the Overworld (sea level 63): None
-    /// without precipitation, else whether it falls as snow
-    /// (`getHeightAdjustedTemperature` below 0.15).
-    pub fn snows_at(&self, x: i32, y: i32, z: i32) -> Option<bool> {
-        self.precipitation
-            .then(|| self.temperature_at(BlockPos::new(x, y, z), 63) < 0.15)
-    }
-}
-/// The game's biomes, by id. The built-in (vanilla) biomes come first, in
-/// file order, and keep their ids whatever a world's data packs do; a pack's
-/// new biomes follow them (`with_packs`). Those are the client's own ids:
-/// the network registry's are `registry_order`'s.
-#[derive(Clone)]
-pub struct Biomes {
-    pub list: Vec<BiomeInfo>,
-    pub index: HashMap<String, u16>,
-    info_noise: SimplexNoise,
-    colormaps: Arc<Colormaps>,
-    /// The built-in biomes, the first of `list` unless packs replaced them.
-    builtin: Arc<Vec<BiomeInfo>>,
-    /// The data packs' biome files (new biomes and replaced built-in ones),
-    /// for the tables that read more of a biome than `BiomeInfo` keeps.
-    packs: BTreeMap<String, Arc<Value>>,
-}
-/// The grass, foliage and dry foliage colormaps.
-struct Colormaps {
-    grass: Vec<u32>,
-    foliage: Vec<u32>,
-    dry: Vec<u32>,
-}
-fn color(v: &Value) -> Option<u32> {
-    match v {
-        Value::String(s) => u32::from_str_radix(s.trim_start_matches('#'), 16)
-            .ok()
-            .map(|c| c & 0xFF_FFFF),
-        Value::Number(n) => n.as_i64().map(|c| c as u32 & 0xFF_FFFF),
-        _ => None,
-    }
-}
-fn colormap(root: &Path, name: &str) -> Result<Vec<u32>> {
-    let path = root.join(format!("assets/minecraft/textures/colormap/{name}.png"));
-    let mut decoder = png::Decoder::new(std::io::BufReader::new(fs::File::open(path)?));
-    decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
-    let mut reader = decoder.read_info()?;
-    let mut bytes = vec![0; reader.output_buffer_size().ok_or("colormap too large")?];
-    let info = reader.next_frame(&mut bytes)?;
-    let channels = info.color_type.samples();
-    Ok(bytes[..info.buffer_size()]
-        .chunks_exact(channels)
-        .map(|p| u32::from(p[0]) << 16 | u32::from(p[1]) << 8 | u32::from(p[2]))
-        .collect())
-}
-/// `GrassColor.get`/`FoliageColor.get`: temperature and downfall index a 256x256 map.
-fn sample(map: &[u32], temperature: f32, downfall: f32, fallback: u32) -> u32 {
-    let temperature = f64::from(temperature.clamp(0.0, 1.0));
-    let downfall = f64::from(downfall.clamp(0.0, 1.0)) * temperature;
-    let x = ((1.0 - temperature) * 255.0) as i32;
-    let y = ((1.0 - downfall) * 255.0) as i32;
-    let index = (y << 8 | x) as usize;
-    map.get(index).copied().unwrap_or(fallback)
-}
-impl BiomeInfo {
-    /// A biome file's (`worldgen/biome/<name>.json`) values, the colours it
-    /// leaves out sampled from the colormaps.
-    fn from_json(name: String, v: &Value, maps: &Colormaps) -> Self {
-        let effects = &v["effects"];
-        let attributes = &v["attributes"];
-        let temperature = v["temperature"].as_f64().unwrap_or(0.5) as f32;
-        let downfall = v["downfall"].as_f64().unwrap_or(0.5) as f32;
-        let modifier = match effects["grass_color_modifier"].as_str() {
-            Some("dark_forest") => GrassModifier::DarkForest,
-            Some("swamp") => GrassModifier::Swamp,
-            _ => GrassModifier::None,
-        };
-        let mut spawns: HashMap<String, Vec<SpawnEntry>> = HashMap::new();
-        let natural = &attributes["minecraft:gameplay/natural_mob_spawns"];
-        // A modifier object ({argument, modifier: overlay}) or the plain value;
-        // the overlay over the dimension's empty default is the biome's value.
-        let natural = if natural["argument"].is_object() {
-            &natural["argument"]
-        } else {
-            natural
-        };
-        let categories = &natural["spawns_by_category"];
-        for (category, entries) in categories.as_object().into_iter().flatten() {
-            let list = parse_entries(entries);
-            spawns.insert(category.clone(), list);
-        }
-        BiomeInfo {
-            spawns,
-            spawn_costs: parse_costs(&natural["spawn_costs"]),
-            creature_probability:
-                attributes["minecraft:gameplay/creature_world_gen_spawn_probability"]
-                    .as_f64()
-                    .unwrap_or(0.1) as f32,
-            increased_fire_burnout: attributes["minecraft:gameplay/increased_fire_burnout"]
-                .as_bool()
-                .unwrap_or(false),
-            temperature,
-            frozen: v["temperature_modifier"].as_str() == Some("frozen"),
-            downfall,
-            precipitation: v["has_precipitation"].as_bool().unwrap_or(true),
-            grass: color(&effects["grass_color"])
-                .unwrap_or_else(|| sample(&maps.grass, temperature, downfall, 0xFF00FF)),
-            modifier,
-            foliage: color(&effects["foliage_color"])
-                .unwrap_or_else(|| sample(&maps.foliage, temperature, downfall, 0x48B518)),
-            dry_foliage: color(&effects["dry_foliage_color"])
-                .unwrap_or_else(|| sample(&maps.dry, temperature, downfall, 0x5D4930)),
-            water: color(&effects["water_color"]).unwrap_or(0x3F76E4),
-            sky: color(&attributes["minecraft:visual/sky_color"]),
-            fog: color(&attributes["minecraft:visual/fog_color"]),
-            water_fog: color(&attributes["minecraft:visual/water_fog_color"]).unwrap_or(0x050533),
-            features: v["features"]
-                .as_array()
-                .into_iter()
-                .flatten()
-                .map(|step| {
-                    step.as_array()
-                        .into_iter()
-                        .flatten()
-                        .filter_map(Value::as_str)
-                        .map(str::to_owned)
-                        .collect()
-                })
-                .collect(),
-            name,
-        }
-    }
-}
-/// `Identifier.compareTo`: the path first, then the namespace.
-pub fn identifier_order(a: &str, b: &str) -> std::cmp::Ordering {
-    fn split(id: &str) -> (&str, &str) {
-        let (ns, path) = id.split_once(':').unwrap_or(("minecraft", id));
-        (path, ns)
-    }
-    split(a).cmp(&split(b))
-}
-impl Biomes {
-    pub fn load(root: &Path) -> Result<Self> {
-        let maps = Colormaps {
-            grass: colormap(root, "grass")?,
-            foliage: colormap(root, "foliage")?,
-            dry: colormap(root, "dry_foliage")?,
-        };
-        let mut list = Vec::new();
-        let mut names: Vec<_> = fs::read_dir(root.join("data/minecraft/worldgen/biome"))?
-            .filter_map(|e| e.ok())
-            .map(|e| e.path())
-            .filter(|p| p.extension().is_some_and(|e| e == "json"))
-            .collect();
-        names.sort();
-        for path in names {
-            let name = format!(
-                "minecraft:{}",
-                path.file_stem()
-                    .and_then(|s| s.to_str())
-                    .ok_or("bad biome")?
-            );
-            let v: Value = serde_json::from_slice(&fs::read(&path)?)?;
-            list.push(BiomeInfo::from_json(name, &v, &maps));
-        }
-        let index = list
-            .iter()
-            .enumerate()
-            .map(|(i, b)| (b.name.clone(), i as u16))
-            .collect();
-        Ok(Self {
-            builtin: Arc::new(list.clone()),
-            list,
-            index,
-            colormaps: Arc::new(maps),
-            packs: BTreeMap::new(),
-            info_noise: SimplexNoise::with_skipped_offsets(&mut LegacyRandom::new(2345), true),
-        })
-    }
-    /// The built-in biomes with a world's data packs' biome files (id →
-    /// JSON) over them, as `RegistryDataLoader` builds the registry: a file
-    /// for a built-in biome replaces it, keeping its id, and new biomes join
-    /// after the built-in ones, in registry order. Starts from the built-in
-    /// table whatever packs `self` has.
-    pub fn with_packs<'a>(&self, files: impl IntoIterator<Item = (&'a str, &'a Value)>) -> Self {
-        let mut out = self.builtin_only();
-        let mut files: Vec<(&str, &Value)> = files.into_iter().collect();
-        files.sort_by(|a, b| identifier_order(a.0, b.0));
-        for (name, json) in files {
-            let info = BiomeInfo::from_json(name.to_owned(), json, &out.colormaps);
-            match out.index.get(name) {
-                Some(&id) => out.list[usize::from(id)] = info,
-                None if out.list.len() < usize::from(u16::MAX) => {
-                    out.index.insert(name.to_owned(), out.list.len() as u16);
-                    out.list.push(info);
-                }
-                None => continue,
-            }
-            out.packs.insert(name.to_owned(), Arc::new(json.clone()));
-        }
-        out
-    }
-    /// The built-in biomes alone: this table without what packs gave it.
-    pub fn builtin_only(&self) -> Self {
-        let mut out = self.clone();
-        if self.packs.is_empty() {
-            return out;
-        }
-        out.list = self.builtin.to_vec();
-        let builtin = out.list.len();
-        out.index.retain(|_, id| usize::from(*id) < builtin);
-        out.packs.clear();
-        out
-    }
-    /// The data pack file a world's biome `name` came from, if a pack added
-    /// or replaced it.
-    pub fn pack_file(&self, name: &str) -> Option<&Value> {
-        self.packs.get(name).map(|v| &**v)
-    }
-    /// Whether data packs added or replaced any biome.
-    pub fn has_packs(&self) -> bool {
-        !self.packs.is_empty()
-    }
-    /// The biome names in the network registry's order: `RegistryDataLoader`
-    /// sorts a registry's files by `Identifier` (path, then namespace).
-    pub fn registry_order(&self) -> Vec<&str> {
-        let mut names: Vec<&str> = self.list.iter().map(|b| b.name.as_str()).collect();
-        names.sort_by(|a, b| identifier_order(a, b));
-        names
-    }
-    pub fn id(&self, name: &str) -> u16 {
-        self.index
-            .get(name)
-            .or_else(|| self.index.get("minecraft:plains"))
-            .copied()
-            .unwrap_or(0)
-    }
-    /// Whether the game has the biome `name`.
-    pub fn contains(&self, name: &str) -> bool {
-        self.index.contains_key(name)
-    }
-    pub fn get(&self, id: u16) -> &BiomeInfo {
-        &self.list[usize::from(id).min(self.list.len() - 1)]
-    }
-    pub fn grass(&self, id: u16, x: f64, z: f64) -> u32 {
-        let b = self.get(id);
-        match b.modifier {
-            GrassModifier::None => b.grass,
-            GrassModifier::DarkForest => ((b.grass & 0xFE_FEFE) + 0x28_340A) >> 1,
-            GrassModifier::Swamp => {
-                if f64::from(self.info_noise.get2(x * 0.0225, z * 0.0225)) < -0.1 {
-                    0x4C_763C
-                } else {
-                    0x6A_7039
-                }
-            }
-        }
-    }
-}
-
-/// A 24-bit colour as sRGB components in 0..1.
-pub fn rgb(c: u32) -> [f32; 3] {
-    [16, 8, 0].map(|shift| (c >> shift & 255) as f32 / 255.0)
-}
-
-/// `GaussianSampler.GAUSSIAN_SAMPLE_KERNEL`.
-const GAUSSIAN_KERNEL: [f64; 7] = [0.0, 1.0, 4.0, 6.0, 4.0, 1.0, 0.0];
-
-/// `EnvironmentAttributeProbe.tick`: `GaussianSampler.sample` over the noise
-/// biomes (quart cells) around `position`, in blocks. Each biome comes once
-/// with its summed weight, in the order it was first sampled, as
-/// `SpatialAttributeInterpolator` keeps them (zero weights included).
-pub fn gaussian_weights(
-    position: [f64; 3],
-    mut biome_at_quart: impl FnMut(i32, i32, i32) -> u16,
-) -> Vec<(u16, f64)> {
-    let p = position.map(|c| c * 0.25 - 0.5);
-    let integral = p.map(|c| c.floor() as i32);
-    let relative: [f64; 3] = std::array::from_fn(|i| p[i] - f64::from(integral[i]));
-    let weight = |axis: usize, i: usize| {
-        let (start, end) = (GAUSSIAN_KERNEL[i + 1], GAUSSIAN_KERNEL[i]);
-        start + relative[axis] * (end - start)
-    };
-    let mut weights: Vec<(u16, f64)> = Vec::new();
-    for z in 0..6 {
-        let wz = weight(2, z);
-        for x in 0..6 {
-            let wx = weight(0, x);
-            for y in 0..6 {
-                let wy = weight(1, y);
-                let biome = biome_at_quart(
-                    integral[0] - 2 + x as i32,
-                    integral[1] - 2 + y as i32,
-                    integral[2] - 2 + z as i32,
-                );
-                let w = wx * wy * wz;
-                match weights.iter_mut().find(|(b, _)| *b == biome) {
-                    Some((_, total)) => *total += w,
-                    None => weights.push((biome, w)),
-                }
-            }
-        }
-    }
-    weights
-}
-
-/// `SpatialAttributeInterpolator.applyAttributeLayer` for an RGB colour
-/// (`ARGB.srgbLerp`: a component-wise lerp of the sRGB values).
-pub fn blend_rgb(weights: &[(u16, f64)], mut value: impl FnMut(u16) -> [f32; 3]) -> [f32; 3] {
-    let mut result: Option<[f32; 3]> = None;
-    let mut accumulated = 0.0;
-    for &(biome, weight) in weights {
-        let v = value(biome);
-        accumulated += weight;
-        result = Some(match result {
-            None => v,
-            Some(r) => {
-                let t = (weight / accumulated) as f32;
-                std::array::from_fn(|i| r[i] + (v[i] - r[i]) * t)
-            }
-        });
-    }
-    result.unwrap_or([0.0; 3])
-}
-
-#[cfg(test)]
-mod pack_tests {
-    use super::*;
-    use serde_json::json;
-
-    /// A built-in table of `names` (no colormaps: sampled colours fall back).
-    fn builtin(names: &[&str]) -> Biomes {
-        let maps = Colormaps {
-            grass: Vec::new(),
-            foliage: Vec::new(),
-            dry: Vec::new(),
-        };
-        let list: Vec<BiomeInfo> = names
-            .iter()
-            .map(|n| BiomeInfo::from_json((*n).to_owned(), &json!({}), &maps))
-            .collect();
-        Biomes {
-            builtin: Arc::new(list.clone()),
-            index: list
-                .iter()
-                .enumerate()
-                .map(|(i, b)| (b.name.clone(), i as u16))
-                .collect(),
-            list,
-            info_noise: SimplexNoise::with_skipped_offsets(&mut LegacyRandom::new(2345), true),
-            colormaps: Arc::new(maps),
-            packs: BTreeMap::new(),
-        }
-    }
-
-    #[test]
-    fn registry_order_is_path_then_namespace() {
-        use std::cmp::Ordering::*;
-        assert_eq!(identifier_order("minecraft:a", "minecraft:b"), Less);
-        assert_eq!(identifier_order("z:a", "a:b"), Less);
-        assert_eq!(identifier_order("b:same", "a:same"), Greater);
-        assert_eq!(identifier_order("minecraft:a", "minecraft:a_b"), Less);
-        assert_eq!(identifier_order("minecraft:a-b", "minecraft:a"), Greater);
-    }
-
-    #[test]
-    fn packs_replace_in_place_and_add_after_the_builtin_biomes() {
-        let base = builtin(&["minecraft:meadow", "minecraft:plains", "minecraft:river"]);
-        let red = json!({"temperature": 2.0, "effects": {"water_color": "#ff0000"}});
-        let hot = json!({"effects": {"grass_color": 0x123456}});
-        let files = [
-            ("pack:zeta", &hot),
-            ("minecraft:molten_peaks", &hot),
-            ("minecraft:river", &red),
-        ];
-        let world = base.with_packs(files);
-        // The built-in ids stay; the river takes the pack's values.
-        assert_eq!(world.id("minecraft:plains"), 1);
-        assert_eq!(world.id("minecraft:river"), 2);
-        assert_eq!(world.get(2).water, 0xFF0000);
-        assert_eq!(world.get(2).temperature, 2.0);
-        // New biomes follow, in registry order.
-        assert_eq!(world.id("minecraft:molten_peaks"), 3);
-        assert_eq!(world.id("pack:zeta"), 4);
-        assert_eq!(world.get(3).grass, 0x123456);
-        assert!(world.pack_file("minecraft:river").is_some());
-        assert!(world.pack_file("minecraft:plains").is_none());
-        // The network registry sorts every name by path, then namespace.
-        assert_eq!(
-            world.registry_order(),
-            [
-                "minecraft:meadow",
-                "minecraft:molten_peaks",
-                "minecraft:plains",
-                "minecraft:river",
-                "pack:zeta"
-            ]
-        );
-        // Another world starts again from the built-in biomes.
-        let other = world.with_packs([]);
-        assert_eq!(other.list.len(), 3);
-        assert!(!other.contains("minecraft:molten_peaks"));
-        assert_eq!(other.get(2).water, 0x3F76E4);
-        assert!(!other.has_packs());
-    }
-}
-
-#[cfg(test)]
-mod blend_tests {
-    use super::*;
-
-    #[test]
-    fn one_biome_keeps_its_colour() {
-        let weights = gaussian_weights([10.3, 64.0, -7.9], |_, _, _| 4);
-        assert_eq!(weights.len(), 1);
-        // The kernel sums to 16 per axis whatever the offset.
-        assert!((weights[0].1 - 16f64.powi(3)).abs() < 1e-9);
-        assert_eq!(blend_rgb(&weights, |_| [0.2, 0.4, 0.6]), [0.2, 0.4, 0.6]);
-    }
-
-    #[test]
-    fn colour_changes_gradually_across_a_boundary() {
-        // Biome 1 for quart x >= 0 (block x >= 0), biome 0 below.
-        let at = |x: f64| {
-            let w = gaussian_weights([x, 40.0, 0.0], |qx, _, _| u16::from(qx >= 0));
-            blend_rgb(&w, |b| if b == 1 { [1.0, 0.0, 0.0] } else { [0.0; 3] })[0]
-        };
-        assert_eq!(at(-12.0), 0.0);
-        assert_eq!(at(12.0), 1.0);
-        // Halfway at the boundary, rising steadily through it.
-        assert!((at(0.0) - 0.5).abs() < 1e-5, "{}", at(0.0));
-        let mut last = 0.0;
-        for i in -16..=16 {
-            let v = at(f64::from(i) * 0.5);
-            assert!(v >= last - 1e-6, "{v} < {last} at {i}");
-            last = v;
-        }
-        assert!(at(-2.0) > 0.0 && at(-2.0) < 0.5);
-    }
-}

crates/horizon-client-render/src/chunk.rs

@@ -1,843 +0,0 @@
-//! Resident client chunk storage. Sections are reference-counted so worker
-//! threads can mesh and light immutable snapshots while the game thread edits
-//! (copy-on-write through `Arc::make_mut`).
-use horizon_core::paletted::{PalettedContainer, Strategy};
-use horizon_world::nbt::{Compound, Tag};
-use horizon_world::registry::BlockStateId;
-use std::sync::{Arc, OnceLock};
-
-pub mod block_entity;
-
-/// The vanilla Overworld's column, which every dimension's chunks hold for
-/// now (`LevelShape::column`).
-pub const MIN_Y: i32 = -64;
-pub const HEIGHT: i32 = 384;
-pub const SECTIONS: usize = (HEIGHT / 16) as usize;
-
-/// A level's build range and skylight, from its dimension type (`min_y`,
-/// `height`, `logical_height`, `has_skylight`), as `LevelHeightAccessor` and
-/// `SerializableChunkData.write` read them.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct LevelShape {
-    pub sky_light: bool,
-    pub min_y: i32,
-    pub height: i32,
-    /// `DimensionType.logicalHeight`: how high portals and chorus fruit reach.
-    pub logical_height: i32,
-}
-impl LevelShape {
-    pub const OVERWORLD: Self = Self {
-        sky_light: true,
-        min_y: MIN_Y,
-        height: HEIGHT,
-        logical_height: HEIGHT,
-    };
-    pub const NETHER: Self = Self {
-        sky_light: false,
-        min_y: 0,
-        height: 256,
-        logical_height: 128,
-    };
-    pub const END: Self = Self {
-        sky_light: true,
-        min_y: 0,
-        height: 256,
-        logical_height: 256,
-    };
-    /// A dimension type's shape, checked as its codec checks it.
-    pub fn new(
-        min_y: i32,
-        height: i32,
-        logical_height: i32,
-        sky_light: bool,
-    ) -> Result<Self, String> {
-        ColumnLayout::new(min_y, height)?;
-        if !(0..=height).contains(&logical_height) {
-            return Err(format!(
-                "logical_height {logical_height} is outside 0..={height}"
-            ));
-        }
-        Ok(Self {
-            sky_light,
-            min_y,
-            height,
-            logical_height,
-        })
-    }
-    /// One above the highest block (`getMaxY() + 1`).
-    pub fn max_y(self) -> i32 {
-        self.min_y + self.height
-    }
-    pub fn min_section(self) -> i32 {
-        self.min_y >> 4
-    }
-    pub fn section_count(self) -> usize {
-        (self.height >> 4) as usize
-    }
-    /// Whether section `y` (a section coordinate) is inside the level.
-    pub fn has_section(self, y: i32) -> bool {
-        (self.min_section()..self.min_section() + self.section_count() as i32).contains(&y)
-    }
-    /// The sections a chunk of this level holds: the level's, widened to the
-    /// vanilla Overworld's `-64..320` so that vanilla's Nether and End keep
-    /// the 24 sections they have always had.
-    pub fn column(self) -> ColumnLayout {
-        ColumnLayout::of_level(self.min_y, self.height)
-    }
-}
-
-/// The shapes of a world's three levels, from its dimension types.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct LevelShapes {
-    pub overworld: LevelShape,
-    pub nether: LevelShape,
-    pub end: LevelShape,
-}
-impl LevelShapes {
-    pub const VANILLA: Self = Self {
-        overworld: LevelShape::OVERWORLD,
-        nether: LevelShape::NETHER,
-        end: LevelShape::END,
-    };
-    /// The shape of the level `id` (`minecraft:overworld`,
-    /// `minecraft:the_nether`, `minecraft:the_end`); others get the
-    /// Overworld's.
-    pub fn get(&self, id: &str) -> LevelShape {
-        match id {
-            "minecraft:the_nether" => self.nether,
-            "minecraft:the_end" => self.end,
-            _ => self.overworld,
-        }
-    }
-    pub fn get_mut(&mut self, id: &str) -> &mut LevelShape {
-        match id {
-            "minecraft:the_nether" => &mut self.nether,
-            "minecraft:the_end" => &mut self.end,
-            _ => &mut self.overworld,
-        }
-    }
-}
-impl Default for LevelShapes {
-    fn default() -> Self {
-        Self::VANILLA
-    }
-}
-
-/// The span of block Y a chunk holds: from `min_y`, `sections` sections up
-/// (`LevelShape::column`).
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct ColumnLayout {
-    min_y: i32,
-    sections: usize,
-}
-impl ColumnLayout {
-    pub const VANILLA: Self = Self {
-        min_y: MIN_Y,
-        sections: SECTIONS,
-    };
-    /// The column of a level from `min_y`, `height` high
-    /// (`LevelShape::column`).
-    pub fn of_level(min_y: i32, height: i32) -> Self {
-        let low = min_y.min(MIN_Y);
-        let high = (min_y + height).max(MIN_Y + HEIGHT);
-        Self {
-            min_y: low,
-            sections: ((high - low) / 16) as usize,
-        }
-    }
-    /// `DimensionType.MIN_Y`, `MAX_Y`: 12 bits of `BlockPos` Y, less 32.
-    pub const LOWEST_Y: i32 = -2032;
-    pub const HIGHEST_Y: i32 = 2031;
-    /// A dimension type's `min_y` and `height`, as its codec accepts them:
-    /// multiples of 16, at least 16 high, within `LOWEST_Y..=HIGHEST_Y`.
-    pub fn new(min_y: i32, height: i32) -> Result<Self, String> {
-        if min_y % 16 != 0 || height % 16 != 0 {
-            return Err(format!(
-                "min_y {min_y} and height {height} must be multiples of 16"
-            ));
-        }
-        if height < 16 {
-            return Err(format!("height {height} is below 16"));
-        }
-        if min_y < Self::LOWEST_Y
-            || i64::from(min_y) + i64::from(height) > i64::from(Self::HIGHEST_Y) + 1
-        {
-            return Err(format!(
-                "min_y {min_y} with height {height} leaves {}..={}",
-                Self::LOWEST_Y,
-                Self::HIGHEST_Y
-            ));
-        }
-        Ok(Self {
-            min_y,
-            sections: (height / 16) as usize,
-        })
-    }
-    pub fn min_y(self) -> i32 {
-        self.min_y
-    }
-    /// One above the highest block.
-    pub fn max_y(self) -> i32 {
-        self.min_y + self.height()
-    }
-    pub fn height(self) -> i32 {
-        self.sections as i32 * 16
-    }
-    pub fn sections(self) -> usize {
-        self.sections
-    }
-    /// The index of the section holding block `y`, if the column holds it.
-    pub fn section_index(self, y: i32) -> Option<usize> {
-        usize::try_from((y - self.min_y) >> 4)
-            .ok()
-            .filter(|&s| s < self.sections)
-    }
-    /// The minimum block Y of section `index`.
-    pub fn section_y(self, index: usize) -> i32 {
-        self.min_y + index as i32 * 16
-    }
-}
-/// `true` for each section of `layout`: what callers that keep no
-/// per-section record (of fluids, say) pass as "every section may have it".
-pub fn every_section(layout: ColumnLayout) -> &'static [bool] {
-    static ALL: [bool; crate::section_mask::SectionMask::CAPACITY] =
-        [true; crate::section_mask::SectionMask::CAPACITY];
-    &ALL[..layout.sections()]
-}
-impl Default for ColumnLayout {
-    fn default() -> Self {
-        Self::VANILLA
-    }
-}
-
-/// Biomes are 4x4x4 containers over the biome table (67 entries: a 7-bit
-/// global palette).
-pub const BIOME_STRATEGY: Strategy = Strategy::biomes(7);
-
-/// Bits of the block states' global palette: 16 for vanilla's 35,723 states
-/// (what vanilla servers and clients send), more when content mods add states
-/// past 65,536 (docs/modpacks.md). Set once, before the first chunk.
-static BLOCK_BITS: std::sync::atomic::AtomicU8 = std::sync::atomic::AtomicU8::new(16);
-
-/// Block states are `PalettedContainer`s over the registry: vanilla's 16-bit
-/// global palette, wider with enough content mods.
-pub fn block_strategy() -> Strategy {
-    Strategy::blocks(BLOCK_BITS.load(std::sync::atomic::Ordering::Relaxed))
-}
-
-/// Frees `columns` (`count` of them) on a short-lived thread of its own
-/// when there are many: a teleport or a dimension change drops a few
-/// thousand columns at once, and freeing their sections took the frame
-/// 15-20 ms. A few are freed here.
-pub fn free_columns<T: Send + 'static>(columns: T, count: usize) {
-    if count < 64 {
-        return;
-    }
-    // Should the thread not start, the closure drops `columns` here.
-    let _ = std::thread::Builder::new()
-        .name("Chunk freeing".into())
-        .spawn(move || drop(columns));
-}
-
-/// Sizes the block states' global palette for a registry of `states`.
-pub fn set_block_states(states: usize) {
-    let bits = horizon_core::paletted::ceil_log2(states).max(16);
-    BLOCK_BITS.store(bits, std::sync::atomic::Ordering::Relaxed);
-    forget_shared();
-}
-
-/// One allocation per kind of uniform section (a single block, a single
-/// biome and one light value), shared by every column that has it, keyed by
-/// (block, biome, light). A tall column is mostly such sections: air with
-/// full sky light above the terrain. Edits copy them (`Arc::make_mut`).
-type SharedSections = std::collections::HashMap<(u32, u32, u8), Arc<Section>>;
-static SHARED: std::sync::Mutex<Option<SharedSections>> = std::sync::Mutex::new(None);
-
-/// Replaces the uniform sections of `sections` with the shared ones.
-pub fn share_uniform(sections: &mut [Arc<Section>]) {
-    let key = |s: &Section| -> Option<(u32, u32, u8)> {
-        let Light::Uniform(light) = s.light else {
-            return None;
-        };
-        if s.blocks.bits() != 0 || s.biomes.bits() != 0 {
-            return None;
-        }
-        Some((s.blocks.uniform()?, s.biomes.uniform()?, light))
-    };
-    let Ok(mut shared) = SHARED.lock() else {
-        return;
-    };
-    let shared = shared.get_or_insert_with(Default::default);
-    for section in sections {
-        let Some(k) = key(section) else {
-            continue;
-        };
-        let one = shared.entry(k).or_insert_with(|| section.clone());
-        if !Arc::ptr_eq(one, section) {
-            *section = one.clone();
-        }
-    }
-}
-
-/// Forgets the shared sections, when the palette changes.
-fn forget_shared() {
-    if let Ok(mut shared) = SHARED.lock() {
-        *shared = None;
-    }
-}
-/// Packed light per block: sky light in the high nibble, block light in the low one.
-#[derive(Clone)]
-pub enum Light {
-    Uniform(u8),
-    Full(Box<[u8; 4096]>),
-}
-impl Light {
-    #[inline]
-    pub fn get(&self, i: usize) -> u8 {
-        match self {
-            Self::Uniform(v) => *v,
-            Self::Full(a) => a[i],
-        }
-    }
-}
-#[inline]
-fn column(x: i32, z: i32) -> usize {
-    ((z & 15) << 4 | (x & 15)) as usize
-}
-#[inline]
-pub fn index(x: i32, y: i32, z: i32) -> usize {
-    ((y & 15) << 8 | (z & 15) << 4 | (x & 15)) as usize
-}
-#[derive(Clone)]
-pub struct Section {
-    pub blocks: PalettedContainer,
-    /// Biome table index per 4x4x4 cell, `(y << 2 | z) << 2 | x`.
-    pub biomes: PalettedContainer,
-    pub light: Light,
-}
-impl Default for Section {
-    fn default() -> Self {
-        Self {
-            blocks: PalettedContainer::new(block_strategy(), 0),
-            biomes: PalettedContainer::new(BIOME_STRATEGY, 0),
-            light: Light::Uniform(0xF0),
-        }
-    }
-}
-impl Section {
-    #[inline]
-    pub fn get(&self, i: usize) -> u32 {
-        self.blocks.get(i)
-    }
-    pub fn set(&mut self, i: usize, v: u32) -> u32 {
-        self.blocks.set(i, v)
-    }
-    /// All 4,096 block states in index order.
-    pub fn unpack(&self, out: &mut [u32; 4096]) {
-        self.blocks.unpack(out);
-    }
-    /// The block states of a whole section at once.
-    pub fn from_blocks(values: &[u32; 4096]) -> PalettedContainer {
-        PalettedContainer::from_values(block_strategy(), values)
-    }
-    #[inline]
-    pub fn light(&self, i: usize) -> u8 {
-        self.light.get(i)
-    }
-    pub fn is_uniform(&self, v: u32) -> bool {
-        self.blocks.is_uniform(v)
-    }
-    /// Heap bytes held by the block, biome and light storage (benchmark accounting).
-    pub fn heap_bytes(&self) -> usize {
-        self.blocks.heap_bytes()
-            + self.biomes.heap_bytes()
-            + match &self.light {
-                Light::Uniform(_) => 0,
-                Light::Full(_) => 4096,
-            }
-    }
-    /// Collapse storage that became uniform, and drop palette entries no
-    /// block uses any more.
-    pub fn compact(&mut self) {
-        for container in [&mut self.blocks, &mut self.biomes] {
-            if container.bits() != 0
-                && let Some(v) = container.uniform()
-            {
-                *container = PalettedContainer::new(container.strategy(), v);
-            }
-        }
-        if let Light::Full(a) = &self.light
-            && a.iter().all(|&b| b == a[0])
-        {
-            self.light = Light::Uniform(a[0]);
-        }
-    }
-}
-#[derive(Clone)]
-pub struct Chunk {
-    pub x: i32,
-    pub z: i32,
-    /// The minimum block Y of `sections[0]` (the layout's when it was made).
-    min_y: i32,
-    pub sections: Vec<Arc<Section>>,
-    /// `Heightmap.Types.WORLD_SURFACE` per column (`z << 4 | x`): one above
-    /// the highest non-air block, or the column's minimum Y. Built on the first read; a
-    /// `set` that can move a column's surface drops it.
-    surface: OnceLock<Box<[i16; 256]>>,
-    /// `Heightmap.Types.MOTION_BLOCKING` per column, kept like `surface`.
-    motion_blocking: OnceLock<Box<[i16; 256]>>,
-    pub lit: bool,
-    /// Light read from a save with `isLightOn`: no light job is needed.
-    pub light_loaded: bool,
-    /// Newly generated (not loaded from a save): eligible for generation-time spawns.
-    pub fresh: bool,
-    /// Block entities read from a save, moved into the world on arrival.
-    pub block_entities: Vec<((i32, i32, i32), block_entity::BlockEntity)>,
-    /// `CustomName` of the container block entities (shown as the screen title).
-    pub block_names: Vec<((i32, i32, i32), String)>,
-    /// Generation postprocessing marks (ProtoChunk.postProcessing) as world
-    /// positions, applied once by LevelChunk.postProcessGeneration.
-    pub postprocess: Vec<[i32; 3]>,
-    /// Saved data Horizon keeps but does not simulate (save.rs).
-    pub saved: Option<Arc<ChunkExtras>>,
-    /// Entities read from a save (vanilla entity NBT), spawned on arrival.
-    pub entities: Vec<horizon_world::nbt::Tag>,
-    /// Structure starts reaching into this chunk (`structures.References`):
-    /// structure id and the start's chunk.
-    pub structure_refs: Vec<(Arc<str>, (i32, i32))>,
-    /// The starts generation made in this chunk (`structures.starts`), saved
-    /// with the state their placement has reached by then.
-    pub structure_starts: Vec<Arc<horizon_world::worldgen::structure::start::StructureStart>>,
-}
-impl Chunk {
-    /// An all-air chunk in the current `layout`.
-    pub fn empty(x: i32, z: i32) -> Self {
-        Self::with_layout(x, z, ColumnLayout::VANILLA)
-    }
-    pub fn with_layout(x: i32, z: i32, layout: ColumnLayout) -> Self {
-        let mut one = [Arc::new(Section::default())];
-        share_uniform(&mut one);
-        let [empty] = one;
-        Self {
-            x,
-            z,
-            min_y: layout.min_y(),
-            sections: (0..layout.sections()).map(|_| empty.clone()).collect(),
-            surface: OnceLock::new(),
-            motion_blocking: OnceLock::new(),
-            lit: false,
-            light_loaded: false,
-            fresh: false,
-            block_entities: Vec::new(),
-            block_names: Vec::new(),
-            structure_refs: Vec::new(),
-            structure_starts: Vec::new(),
-            postprocess: Vec::new(),
-            saved: None,
-            entities: Vec::new(),
-        }
-    }
-    /// The minimum block Y of the column.
-    #[inline]
-    pub fn min_y(&self) -> i32 {
-        self.min_y
-    }
-    /// The column the chunk holds.
-    pub fn layout(&self) -> ColumnLayout {
-        ColumnLayout {
-            min_y: self.min_y,
-            sections: self.sections.len(),
-        }
-    }
-    /// One above the column's highest block.
-    #[inline]
-    pub fn max_y(&self) -> i32 {
-        self.min_y + self.sections.len() as i32 * 16
-    }
-    /// The index of the section holding block `y`, if the column holds it.
-    #[inline]
-    pub fn section_index(&self, y: i32) -> Option<usize> {
-        usize::try_from((y - self.min_y) >> 4)
-            .ok()
-            .filter(|&s| s < self.sections.len())
-    }
-    #[inline]
-    pub fn get(&self, x: i32, y: i32, z: i32) -> u32 {
-        match self.section_index(y) {
-            Some(s) => self.sections[s].get(index(x, y, z)),
-            None => 0,
-        }
-    }
-    #[inline]
-    pub fn block(&self, x: i32, y: i32, z: i32) -> BlockStateId {
-        BlockStateId(self.get(x, y, z))
-    }
-    /// The highest y where `matches`, scanning down. Sections holding only
-    /// `skip` are passed over whole: `matches` must be false for it.
-    pub fn highest(&self, skip: u32, mut matches: impl FnMut(i32) -> bool) -> Option<i32> {
-        self.sections
-            .iter()
-            .enumerate()
-            .rev()
-            .filter(|(_, section)| !section.is_uniform(skip))
-            .find_map(|(s, _)| {
-                let base = self.min_y + s as i32 * 16;
-                (base..base + 16).rev().find(|&y| matches(y))
-            })
-    }
-    pub fn set(&mut self, x: i32, y: i32, z: i32, v: u32) -> u32 {
-        let Some(s) = self.section_index(y) else {
-            return v;
-        };
-        let previous = Arc::make_mut(&mut self.sections[s]).set(index(x, y, z), v);
-        // `Heightmap.update`: a write two or more below a map's height can't
-        // move it. Any other change rebuilds that map on the next read.
-        if previous != v {
-            for map in [&mut self.surface, &mut self.motion_blocking] {
-                if map
-                    .get()
-                    .is_some_and(|heights| y >= i32::from(heights[column(x, z)]) - 1)
-                {
-                    *map = OnceLock::new();
-                }
-            }
-        }
-        previous
-    }
-    /// `getHeight(Heightmap.Types.WORLD_SURFACE, x, z)` (`x`, `z` within the
-    /// chunk): one above the highest block that isn't `air`, or the column's
-    /// minimum Y.
-    /// Sections must change only through `set` once this has been read.
-    pub fn world_surface(&self, x: i32, z: i32, air: impl Fn(u32) -> bool) -> i32 {
-        let surface = self.surface.get_or_init(|| self.prime(|v| !air(v)));
-        i32::from(surface[column(x, z)])
-    }
-    /// `getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)` (`x`, `z` within
-    /// the chunk): one above the highest state where `blocks` (a motion
-    /// blocking block or a fluid), or the column's minimum Y. Kept as
-    /// `world_surface` is.
-    pub fn motion_blocking(&self, x: i32, z: i32, blocks: impl Fn(u32) -> bool) -> i32 {
-        let heights = self.motion_blocking.get_or_init(|| self.prime(blocks));
-        i32::from(heights[column(x, z)])
-    }
-    /// `Heightmap.primeHeightmaps`: each section from the top, skipping
-    /// those of one state that doesn't count, until every column is found.
-    fn prime(&self, counts: impl Fn(u32) -> bool) -> Box<[i16; 256]> {
-        let mut surface = Box::new([self.min_y as i16; 256]);
-        let mut found = [false; 256];
-        let mut left = 256;
-        let mut values = [0u32; 4096];
-        for (s, section) in self.sections.iter().enumerate().rev() {
-            if left == 0 {
-                break;
-            }
-            if section.blocks.uniform().is_some_and(|v| !counts(v)) {
-                continue;
-            }
-            section.unpack(&mut values);
-            let base = self.min_y + s as i32 * 16;
-            for i in 0..256 {
-                if found[i] {
-                    continue;
-                }
-                if let Some(dy) = (0..16).rev().find(|&dy| counts(values[dy << 8 | i])) {
-                    surface[i] = (base + dy as i32 + 1) as i16;
-                    found[i] = true;
-                    left -= 1;
-                }
-            }
-        }
-        surface
-    }
-    #[inline]
-    pub fn light(&self, x: i32, y: i32, z: i32) -> u8 {
-        let s = (y - self.min_y) >> 4;
-        if s < 0 {
-            return 0;
-        }
-        if s >= self.sections.len() as i32 {
-            return 0xF0;
-        }
-        self.sections[s as usize].light(index(x, y, z))
-    }
-    /// Heap bytes held by the sections (benchmark accounting).
-    pub fn heap_bytes(&self) -> usize {
-        self.sections.iter().map(|s| s.heap_bytes()).sum::<usize>()
-    }
-    /// Biome table index at a block position (`ChunkAccess.getNoiseBiome` with
-    /// the quart y clamped to the column).
-    #[inline]
-    pub fn biome(&self, x: i32, y: i32, z: i32) -> u16 {
-        let qy = ((y - self.min_y) >> 2).clamp(0, self.sections.len() as i32 * 4 - 1);
-        self.sections[(qy >> 2) as usize]
-            .biomes
-            .get(((qy & 3) << 4 | ((z & 15) >> 2) << 2 | (x & 15) >> 2) as usize) as u16
-    }
-    /// Sets the biome of one quart cell (`qy` counts from the column's bottom).
-    pub fn set_biome_cell(&mut self, qx: i32, qy: i32, qz: i32, biome: u16) {
-        let section = Arc::make_mut(&mut self.sections[(qy >> 2) as usize]);
-        section.biomes.set(
-            ((qy & 3) << 4 | (qz & 3) << 2 | (qx & 3)) as usize,
-            u32::from(biome),
-        );
-    }
-}
-
-/// A proto chunk saved before it became final. Decoration writes into a
-/// chunk's neighbours, and decorated chunks wait for theirs, so the chunks
-/// past the finished ones hold writes that generating them again would lose
-/// (whole structure pieces, trees, ores). Vanilla saves its proto chunks too.
-pub struct SavedProto {
-    /// Blocks, scheduled ticks (in `saved`) and post-processing marks.
-    pub column: Chunk,
-    /// Decorated itself (`features`), not only written to by its neighbours
-    /// (`terrain`).
-    pub decorated: bool,
-    /// Block entity data in placement order, with `x`, `y` and `z`.
-    pub block_entities: Vec<Tag>,
-    /// Entities placed by structures, with absolute `Pos`.
-    pub entities: Vec<Tag>,
-}
-
-/// A container's loot table and what Horizon rolled from it. Vanilla keeps
-/// `LootTable` and `LootTableSeed` until the container is first opened;
-/// Horizon rolls when it generates or loads the chunk, and saves the table
-/// again while the container still holds exactly the rolled items.
-#[derive(Clone, Debug, PartialEq)]
-pub struct RolledLoot {
-    pub pos: (i32, i32, i32),
-    pub table: String,
-    /// The saved `LootTableSeed`, written back unless 0 (trySaveLootTable).
-    pub seed: Option<i64>,
-    /// The rolled `Items`.
-    pub items: Tag,
-}
-impl RolledLoot {
-    /// Puts the loot table back in place of `Items` while they are still the
-    /// roll; false once the container holds anything else.
-    pub fn restore(&self, map: &mut Compound) -> bool {
-        if map.get(&"Items".into()) != Some(&self.items) {
-            return false;
-        }
-        map.remove(&"Items".into());
-        map.insert("LootTable".into(), Tag::String(self.table.as_str().into()));
-        if let Some(seed) = self.seed.filter(|s| *s != 0) {
-            map.insert("LootTableSeed".into(), Tag::Long(seed));
-        }
-        true
-    }
-}
-
-/// Save data loaded with a chunk that Horizon keeps but does not simulate.
-#[derive(Clone, Debug, Default)]
-pub struct ChunkExtras {
-    /// Chunk root keys written back as loaded (structures, PostProcessing,
-    /// InhabitedTime, blending data, ...).
-    pub root: Compound,
-    /// Block entities Horizon does not model.
-    pub block_entities: Vec<Tag>,
-    /// The NBT of the modelled block entities as loaded, to restore the fields and
-    /// detail Horizon does not model when it saves them (`block_entity_nbt::overlay`).
-    pub block_entity_sources: Vec<((i32, i32, i32), Tag)>,
-    /// Every saved block entity's position in the order of the save's list,
-    /// the order `SerializableChunkData` puts them in the chunk's maps.
-    pub block_entity_order: Vec<(i32, i32, i32)>,
-    /// Scheduled ticks (`block_ticks`/`fluid_ticks`): delays relative to the
-    /// save time. Registered with the level's tick scheduler on arrival and
-    /// replaced with the scheduler's pending ticks when saving.
-    pub block_ticks: Vec<horizon_core::ticks::SavedTick>,
-    pub fluid_ticks: Vec<horizon_core::ticks::SavedTick>,
-    /// Game time written as `LastUpdate`.
-    pub last_update: i64,
-    /// Containers still holding their loot table's roll.
-    pub rolled_loot: Vec<RolledLoot>,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[test]
-    fn highest_skips_only_sections_that_cannot_match() {
-        let (air, cave_air, stone) = (0, 7, 1);
-        let mut chunk = Chunk::empty(0, 0);
-        // Stone low down, cave air (uniform in its section) above it, and a
-        // section of air with one stone block higher up.
-        for y in MIN_Y..MIN_Y + 40 {
-            chunk.set(3, y, 4, stone);
-        }
-        for i in 0..4096 {
-            Arc::make_mut(&mut chunk.sections[5]).set(i, cave_air);
-        }
-        chunk.set(3, 150, 4, stone);
-        let full = |c: &Chunk, matches: &dyn Fn(u32) -> bool| {
-            (MIN_Y..MIN_Y + HEIGHT)
-                .rev()
-                .find(|&y| matches(c.get(3, y, 4)))
-        };
-        for matches in [
-            &(|v: u32| v != air) as &dyn Fn(u32) -> bool,
-            &|v: u32| v == stone,
-            &|v: u32| v == cave_air,
-        ] {
-            let fast = chunk.highest(air, |y| matches(chunk.get(3, y, 4)));
-            assert_eq!(fast, full(&chunk, matches));
-        }
-        assert_eq!(
-            chunk.highest(air, |y| chunk.get(3, y, 4) == stone),
-            Some(150)
-        );
-        assert_eq!(Chunk::empty(0, 0).highest(air, |_| unreachable!()), None);
-    }
-    /// The kept WORLD_SURFACE heights match a scan of every column after
-    /// each of a few thousand writes (air, cave air, stone, whole sections).
-    #[test]
-    fn world_surface_follows_writes() {
-        let (air, cave_air, stone) = (0, 7, 1);
-        let is_air = |v: u32| v == air || v == cave_air;
-        let scan = |c: &Chunk, x: i32, z: i32| {
-            (MIN_Y..MIN_Y + HEIGHT)
-                .rev()
-                .find(|&y| !is_air(c.get(x, y, z)))
-                .map_or(MIN_Y, |y| y + 1)
-        };
-        let mut chunk = Chunk::empty(0, 0);
-        assert_eq!(chunk.world_surface(5, 5, is_air), MIN_Y);
-        for y in MIN_Y..MIN_Y + 70 {
-            for i in 0..256 {
-                chunk.set(i & 15, y, i >> 4, stone);
-            }
-        }
-        for i in 0..4096 {
-            Arc::make_mut(&mut chunk.sections[8]).set(i, cave_air);
-        }
-        let mut random = horizon_core::random::LegacyRandom::new(9);
-        use horizon_core::random::RandomSource;
-        for step in 0..4000 {
-            let x = random.next_int_bound(16).unwrap();
-            let z = random.next_int_bound(16).unwrap();
-            let y = MIN_Y + 40 + random.next_int_bound(120).unwrap();
-            let v = [air, cave_air, stone][random.next_int_bound(3).unwrap() as usize];
-            chunk.set(x, y, z, v);
-            if step % 7 == 0 {
-                for i in 0..256 {
-                    assert_eq!(
-                        chunk.world_surface(i & 15, i >> 4, is_air),
-                        scan(&chunk, i & 15, i >> 4)
-                    );
-                }
-            }
-        }
-        // Out-of-range writes and unchanged states keep the map.
-        let before = chunk.world_surface(3, 3, is_air);
-        chunk.set(3, MIN_Y + HEIGHT, 3, stone);
-        chunk.set(3, before - 1, 3, chunk.get(3, before - 1, 3));
-        assert!(chunk.surface.get().is_some());
-        assert_eq!(chunk.world_surface(3, 3, |_| unreachable!()), before);
-    }
-    /// MOTION_BLOCKING ignores states that don't count (air, grass) and
-    /// follows writes as the surface map does, both maps kept at once.
-    #[test]
-    fn motion_blocking_follows_writes() {
-        let (air, grass, water, stone) = (0, 3, 5, 1);
-        let blocks = |v: u32| v == water || v == stone;
-        let scan = |c: &Chunk, x: i32, z: i32| {
-            (MIN_Y..MIN_Y + HEIGHT)
-                .rev()
-                .find(|&y| blocks(c.get(x, y, z)))
-                .map_or(MIN_Y, |y| y + 1)
-        };
-        let mut chunk = Chunk::empty(0, 0);
-        assert_eq!(chunk.motion_blocking(5, 5, blocks), MIN_Y);
-        for y in MIN_Y..MIN_Y + 70 {
-            for i in 0..256 {
-                chunk.set(i & 15, y, i >> 4, stone);
-            }
-        }
-        for i in 0..4096 {
-            Arc::make_mut(&mut chunk.sections[8]).set(i, grass);
-        }
-        let mut random = horizon_core::random::LegacyRandom::new(11);
-        use horizon_core::random::RandomSource;
-        for step in 0..4000 {
-            let x = random.next_int_bound(16).unwrap();
-            let z = random.next_int_bound(16).unwrap();
-            let y = MIN_Y + 40 + random.next_int_bound(120).unwrap();
-            let v = [air, grass, water, stone][random.next_int_bound(4).unwrap() as usize];
-            chunk.set(x, y, z, v);
-            if step % 7 == 0 {
-                for i in 0..256 {
-                    assert_eq!(
-                        chunk.motion_blocking(i & 15, i >> 4, blocks),
-                        scan(&chunk, i & 15, i >> 4)
-                    );
-                    chunk.world_surface(i & 15, i >> 4, |v| v == air);
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn shapes_follow_the_dimension_type_codec() {
-        assert_eq!(ColumnLayout::new(-64, 384), Ok(ColumnLayout::VANILLA));
-        assert_eq!(ColumnLayout::default(), ColumnLayout::VANILLA);
-        // To The Max's Overworld: the highest top vanilla allows.
-        let tall = ColumnLayout::new(-64, 2096).unwrap();
-        assert_eq!((tall.sections(), tall.max_y()), (131, 2032));
-        assert!(ColumnLayout::new(-2032, 4064).is_ok());
-        for (min_y, height) in [(-64, 2112), (-2048, 64), (-60, 384), (0, 250), (0, 0)] {
-            assert!(
-                ColumnLayout::new(min_y, height).is_err(),
-                "{min_y} {height}"
-            );
-        }
-        assert_eq!(tall.section_index(-65), None);
-        assert_eq!(tall.section_index(-64), Some(0));
-        assert_eq!(tall.section_index(2031), Some(130));
-        assert_eq!(tall.section_index(2032), None);
-        assert_eq!(tall.section_y(130), 2016);
-        assert_eq!(
-            LevelShape::new(-64, 384, 384, true),
-            Ok(LevelShape::OVERWORLD)
-        );
-        assert_eq!(LevelShape::new(0, 256, 128, false), Ok(LevelShape::NETHER));
-        assert!(LevelShape::new(0, 256, 257, true).is_err());
-        assert!(LevelShape::new(-60, 384, 384, true).is_err());
-    }
-
-    #[test]
-    fn vanilla_levels_keep_the_overworld_column() {
-        for shape in [LevelShape::OVERWORLD, LevelShape::NETHER, LevelShape::END] {
-            assert_eq!(shape.column(), ColumnLayout::VANILLA, "{shape:?}");
-        }
-        let tall = LevelShape::new(-64, 2096, 2096, true).unwrap();
-        assert_eq!(tall.column(), ColumnLayout::new(-64, 2096).unwrap());
-        let deep = LevelShape::new(-512, 256, 256, false).unwrap();
-        assert_eq!(deep.column(), ColumnLayout::new(-512, 832).unwrap());
-        assert!(LevelShape::NETHER.has_section(15) && !LevelShape::NETHER.has_section(16));
-        assert!(!LevelShape::NETHER.has_section(-1));
-    }
-
-    #[test]
-    fn a_tall_column_stores_its_whole_height() {
-        let layout = ColumnLayout::new(-64, 2096).unwrap();
-        let mut chunk = Chunk::with_layout(0, 0, layout);
-        assert_eq!(
-            (chunk.min_y(), chunk.max_y(), chunk.sections.len()),
-            (-64, 2032, 131)
-        );
-        let stone = 1;
-        assert_eq!(chunk.set(5, 2031, 6, stone), 0);
-        assert_eq!(chunk.set(5, 2032, 6, stone), stone, "above the column");
-        assert_eq!(chunk.get(5, 2031, 6), stone);
-        assert_eq!(chunk.get(5, 2032, 6), 0);
-        assert_eq!(chunk.world_surface(5, 6, |v| v == 0), 2032);
-        assert_eq!(chunk.world_surface(0, 0, |v| v == 0), -64);
-        assert_eq!(chunk.highest(0, |y| y < 1000), None);
-        chunk.set(5, 999, 6, stone);
-        assert_eq!(chunk.highest(0, |y| y < 1000), Some(999));
-        assert_eq!(chunk.light(0, 2100, 0), 0xF0);
-        assert_eq!(chunk.light(0, -65, 0), 0);
-        chunk.set_biome_cell(0, 130 * 4 + 3, 0, 9);
-        assert_eq!(chunk.biome(0, 5000, 0), 9);
-    }
-}

crates/horizon-client-render/src/chunk/block_entity.rs

@@ -1,510 +0,0 @@
-//! Block entity data: what a chunk stores for its block entities (`BlockEntity`
-//! and its payloads). Plain data, as vanilla's block entities are world data;
-//! their behaviour lives with the features that use them (`containers`,
-//! `brewing`, `signs`, ...), which re-export these types under their old paths.
-use horizon_client_core::{text::Text, who::Who};
-use horizon_items::{banner_layer::BannerLayer, items::ItemStack};
-use horizon_world::{
-    level::sculk::SculkSpreader,
-    nbt::{Compound, Tag},
-};
-use std::{collections::HashMap, sync::Arc};
-
-/// An entity's UUID as its four ints (`UUIDUtil.CODEC`).
-pub type Uuid = [i32; 4];
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum FurnaceKind {
-    Furnace,
-    BlastFurnace,
-    Smoker,
-}
-#[derive(Clone, Debug)]
-pub struct Furnace {
-    pub kind: FurnaceKind,
-    /// input, fuel, result
-    pub items: [Option<ItemStack>; 3],
-    pub lit_remaining: i32,
-    pub lit_total: i32,
-    pub cooking_timer: i32,
-    pub cooking_total: i32,
-    pub speed: f32,
-    /// `AbstractFurnaceBlockEntity.recipesUsed`: how many of each recipe this furnace has
-    /// made since a player last took from its output. The experience is owed per recipe
-    /// rather than per item, and a save keeps it as the `RecipesUsed` compound.
-    pub recipes_used: HashMap<String, u32>,
-}
-#[derive(Clone, Debug)]
-pub enum BlockEntity {
-    Chest(Vec<Option<ItemStack>>),
-    Furnace(Furnace),
-    Brewing(Box<BrewingStand>),
-    /// Signs and hanging signs (`SignBlockEntity`).
-    Sign(SignData),
-    /// `JukeboxBlockEntity`: the record and its `JukeboxSongPlayer`.
-    Jukebox(Jukebox),
-    /// `BeaconBlockEntity`.
-    Beacon(Box<Beacon>),
-    /// `LecternBlockEntity`: the book and the open page.
-    Lectern(Lectern),
-    /// Sculk sensors, shriekers and catalysts (`crate::sculk`).
-    Sculk(Box<SculkEntity>),
-    /// `CreakingHeartBlockEntity`: its protector and the hurt emitter.
-    CreakingHeart(Box<CreakingHeart>),
-    /// `BannerBlockEntity`: the pattern layers.
-    Banner(Banner),
-    /// `CrafterBlockEntity`.
-    Crafter(Crafter),
-    /// `SpawnerBlockEntity` (`crate::mobs::spawner`).
-    Spawner(Box<Spawner>),
-    /// `TrialSpawnerBlockEntity` (`crate::mobs::trial_spawner`).
-    TrialSpawner(Box<TrialSpawner>),
-    /// `VaultBlockEntity` (`crate::vault`).
-    Vault(Box<Vault>),
-    /// `BeehiveBlockEntity` of beehives and bee nests (`crate::beehive`).
-    Beehive(Box<Beehive>),
-    /// `CommandBlockEntity` of the three command blocks (`crate::command_block`).
-    CommandBlock(Box<CommandBlock>),
-    /// `CampfireBlockEntity` of campfires and soul campfires.
-    Campfire(Box<Campfire>),
-    /// `SkullBlockEntity` of every skull and head block.
-    Skull(Skull),
-    /// `TheEndGatewayBlockEntity`: its age and configured destination.
-    EndGateway(EndGateway),
-    /// `DaylightDetectorBlockEntity`: no data, only the ticker
-    /// (`DaylightDetectorBlock.tickEntity`).
-    DaylightDetector,
-    /// Suspicious sand and gravel: saved loot and the transient brushed face.
-    Brushable(Box<Brushable>),
-    /// A shelf holds three displayed item stacks.
-    Shelf(Box<Shelf>),
-    /// `ChiseledBookShelfBlockEntity`: a `Container` of six one-book slots.
-    ChiseledBookshelf(Box<ChiseledBookshelf>),
-    /// `PotentSulfurBlockEntity` (`game/potent_sulfur.rs`).
-    PotentSulfur(PotentSulfur),
-}
-/// `PotentSulfurBlockEntity`: the seconds left to the geyser's next change of
-/// state (`waitingCountdown`, saved as `countdown`) and the game time of its
-/// last eruption block event, which the client's plume counts from.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct PotentSulfur {
-    pub waiting_countdown: i32,
-    pub eruption_tick: i64,
-}
-impl Default for PotentSulfur {
-    fn default() -> Self {
-        Self {
-            waiting_countdown: -1,
-            eruption_tick: -1,
-        }
-    }
-}
-/// `BrushableBlockEntity`: the loot table is resolved on the first brush.
-#[derive(Clone, Debug, Default)]
-pub struct Brushable {
-    pub loot_table: Option<horizon_world::nbt::Tag>,
-    pub loot_seed: Option<horizon_world::nbt::Tag>,
-    pub item: Option<ItemStack>,
-    /// Direction's legacy network id; not saved to disk by vanilla.
-    pub hit_direction: Option<i32>,
-}
-/// `ShelfBlockEntity`'s displayed slots and alignment flag.
-#[derive(Clone, Debug, Default)]
-pub struct Shelf {
-    pub items: [Option<ItemStack>; 3],
-    pub align_to_bottom: bool,
-}
-/// `ChiseledBookShelfBlockEntity`: six slots and `lastInteractedSlot`.
-#[derive(Clone, Debug, PartialEq)]
-pub struct ChiseledBookshelf {
-    pub items: [Option<ItemStack>; 6],
-    pub last_slot: i32,
-}
-impl Default for ChiseledBookshelf {
-    fn default() -> Self {
-        Self {
-            items: Default::default(),
-            last_slot: -1,
-        }
-    }
-}
-/// `TheEndGatewayBlockEntity`.
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct EndGateway {
-    pub age: i64,
-    pub exit_portal: Option<[i32; 3]>,
-    pub exact_teleport: bool,
-}
-/// `CampfireBlockEntity`: four cooking slots, each with its
-/// `cookingProgress` and `cookingTime` (the recipe's).
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct Campfire {
-    pub items: [Option<ItemStack>; 4],
-    pub progress: [i32; 4],
-    pub total: [i32; 4],
-}
-/// `SkullBlockEntity`: the player profile the head shows (kept as loaded:
-/// a compound, or a string when it names a player only), the note block
-/// sound and `custom_name`.
-#[derive(Clone, Debug, Default)]
-pub struct Skull {
-    pub profile: Option<horizon_world::nbt::Tag>,
-    pub note_block_sound: Option<String>,
-    pub custom_name: Option<horizon_world::nbt::Tag>,
-    /// What `profile` draws, read from it once rather than every frame.
-    pub skin: Option<SkullSkin>,
-}
-/// `SkullBlockRenderer.getPlayerSkin` of a head's profile: its skin's URL
-/// with the `skins/<sha1>` sprite it downloads to, and the
-/// `DefaultPlayerSkin` drawn until that sprite is there (steve for a
-/// profile with no id).
-#[derive(Clone, Debug)]
-pub struct SkullSkin {
-    pub download: Option<(String, String)>,
-    /// `ResolvableProfile.nameOrId` when the profile is `Dynamic` (a name or
-    /// an id only): the key `skins::Resolver` resolves it by.
-    pub dynamic: Option<NameOrId>,
-    pub fallback: &'static str,
-}
-/// `Either<String, UUID>`: the key a `Dynamic` `ResolvableProfile` resolves
-/// by (`ResolvableProfile.nameOrId`).
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub enum NameOrId {
-    Name(String),
-    Id(u128),
-}
-/// `CrafterBlockEntity`: nine slots that can be disabled, the powered flag
-/// and the ticks left in the crafting animation.
-#[derive(Clone, Debug, Default)]
-pub struct Crafter {
-    pub items: [Option<ItemStack>; 9],
-    pub disabled: [bool; 9],
-    pub triggered: bool,
-    pub crafting_ticks: i32,
-    /// The block state's `triggered` when last ticked (not saved): the block
-    /// entity flag follows it only when it changes (`CrafterBlock.neighborChanged`).
-    pub state_triggered: Option<bool>,
-}
-#[derive(Clone, Debug, Default)]
-pub struct Banner {
-    pub layers: Vec<BannerLayer>,
-    pub name: Option<String>,
-    /// Components not consumed by BannerBlockEntity's implicit fields.
-    pub components: horizon_world::nbt::Compound,
-}
-/// `CreakingHeartBlockEntity` (the logic is in `game/creaking.rs`).
-#[derive(Clone, Debug, Default)]
-pub struct CreakingHeart {
-    /// The protector: its entity id once resolved, and its UUID (the saved form).
-    pub creaking: Option<(Option<u32>, [i32; 4])>,
-    pub ticks_existed: i64,
-    pub ticker: i32,
-    /// Ticks left of the hurt effect (`emitter`) and where it heads.
-    pub emitter: i32,
-    pub emitter_target: Option<[f64; 3]>,
-    pub output_signal: i32,
-}
-#[derive(Clone, Debug, Default)]
-pub struct Lectern {
-    pub book: Option<ItemStack>,
-    pub page: i32,
-}
-#[derive(Clone, Debug, Default)]
-pub struct Beacon {
-    pub levels: i32,
-    /// Effect ids (`minecraft:speed`).
-    pub primary: Option<String>,
-    pub secondary: Option<String>,
-    /// Beam sections (RGB colour, height) and the ones being rebuilt.
-    pub sections: Vec<(u32, i32)>,
-    pub checking: Vec<(u32, i32)>,
-    pub last_check_y: i32,
-}
-#[derive(Clone, Debug, Default)]
-pub struct Jukebox {
-    pub record: Option<ItemStack>,
-    /// `ticks_since_song_started`, while a song plays.
-    pub ticks: i64,
-    pub playing: bool,
-}
-/// `BrewingStandBlockEntity` state. Slots: 0-2 bottles, 3 ingredient, 4 fuel.
-#[derive(Clone, Debug, Default)]
-pub struct BrewingStand {
-    pub items: [Option<ItemStack>; 5],
-    pub brew_time: i32,
-    pub total_brew_time: i32,
-    pub fuel: i32,
-    pub total_fuel: i32,
-    pub speed: f32,
-    pub ingredient: Option<Arc<str>>,
-    pub last_bottles: Option<[bool; 3]>,
-}
-/// One sign side (`SignText`).
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct SignText {
-    pub lines: [String; 4],
-    /// `DyeColor` id.
-    pub color: u8,
-    pub glowing: bool,
-    /// The `click_event` in each line's component style, as saved.
-    pub click: [Option<Tag>; 4],
-}
-/// `SignBlockEntity` / `HangingSignBlockEntity` data.
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct SignData {
-    pub hanging: bool,
-    pub front: SignText,
-    pub back: SignText,
-    pub waxed: bool,
-    /// `allow_op_features`: the sign's click events may run commands.
-    pub allow_op_features: bool,
-}
-/// `VibrationInfo`.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Info {
-    pub event: &'static str,
-    pub distance: f32,
-    pub pos: [f64; 3],
-    pub source: Option<Who>,
-    pub owner: Option<Who>,
-}
-/// `VibrationSelector`: the closest, then highest-frequency candidate of a tick.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct Selector {
-    pub current: Option<(Info, i64)>,
-}
-/// `VibrationSystem.Data`.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct Data {
-    pub current: Option<Info>,
-    pub travel: i32,
-    pub selector: Selector,
-}
-/// Which sculk block entity this is.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum SculkKind {
-    Sensor,
-    Calibrated,
-    Shrieker,
-    Catalyst,
-}
-/// `SculkSensorBlockEntity`, `CalibratedSculkSensorBlockEntity`,
-/// `SculkShriekerBlockEntity` and `SculkCatalystBlockEntity`.
-#[derive(Clone, Debug)]
-pub struct SculkEntity {
-    pub kind: SculkKind,
-    pub vibration: Data,
-    /// `last_vibration_frequency` (sensors).
-    pub last_frequency: i32,
-    /// `warning_level` (shriekers).
-    pub warning_level: i32,
-    /// The catalyst's charge cursors.
-    pub spreader: SculkSpreader,
-}
-/// `SpawnData.CustomSpawnRules`: the block and sky light the spawn block
-/// must have (inclusive ranges within 0..=15).
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct CustomSpawnRules {
-    pub block: (i32, i32),
-    pub sky: (i32, i32),
-}
-/// `SpawnData`: the entity to spawn, optional light rules and an equipment
-/// table (kept as loaded).
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct SpawnData {
-    pub entity: Compound,
-    pub custom_spawn_rules: Option<CustomSpawnRules>,
-    pub equipment: Option<Tag>,
-}
-/// Which `SpawnData` is next: one of the potentials (the same object in
-/// vanilla, so changing it changes the potential) or its own.
-#[derive(Clone, Debug, PartialEq)]
-pub enum Next {
-    Potential(usize),
-    Own(SpawnData),
-}
-/// `BaseSpawner`.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Spawner {
-    pub spawn_delay: i32,
-    /// `SpawnPotentials`: data and weight.
-    pub potentials: Vec<(SpawnData, i32)>,
-    pub next: Option<Next>,
-    pub min_spawn_delay: i32,
-    pub max_spawn_delay: i32,
-    pub spawn_count: i32,
-    pub max_nearby_entities: i32,
-    pub required_player_range: i32,
-    pub spawn_range: i32,
-    /// The client copy's delay (`spawnDelay` on the client level), which
-    /// speeds the spin up as the next spawn nears.
-    pub client_delay: i32,
-    pub spin: f64,
-    pub o_spin: f64,
-}
-impl Default for Spawner {
-    fn default() -> Self {
-        Self {
-            spawn_delay: 20,
-            potentials: Vec::new(),
-            next: None,
-            min_spawn_delay: 200,
-            max_spawn_delay: 800,
-            spawn_count: 4,
-            max_nearby_entities: 6,
-            required_player_range: 16,
-            spawn_range: 4,
-            client_delay: 20,
-            spin: 0.0,
-            o_spin: 0.0,
-        }
-    }
-}
-/// `TrialSpawnerConfig`.
-#[derive(Clone, Debug, PartialEq)]
-pub struct TrialConfig {
-    pub spawn_range: i32,
-    pub total_mobs: f32,
-    pub simultaneous_mobs: f32,
-    pub total_mobs_added_per_player: f32,
-    pub simultaneous_mobs_added_per_player: f32,
-    pub ticks_between_spawn: i32,
-    pub spawn_potentials: Vec<(SpawnData, i32)>,
-    pub loot_tables_to_eject: Vec<(String, i32)>,
-    pub items_to_drop_when_ominous: String,
-}
-impl Default for TrialConfig {
-    /// `TrialSpawnerConfig.Builder`'s defaults.
-    fn default() -> Self {
-        Self {
-            spawn_range: 4,
-            total_mobs: 6.0,
-            simultaneous_mobs: 2.0,
-            total_mobs_added_per_player: 2.0,
-            simultaneous_mobs_added_per_player: 1.0,
-            ticks_between_spawn: 40,
-            spawn_potentials: Vec::new(),
-            loot_tables_to_eject: vec![
-                ("minecraft:spawners/trial_chamber/consumables".into(), 1),
-                ("minecraft:spawners/trial_chamber/key".into(), 1),
-            ],
-            items_to_drop_when_ominous:
-                "minecraft:spawners/trial_chamber/items_to_drop_when_ominous".into(),
-        }
-    }
-}
-/// A `Holder<TrialSpawnerConfig>` as saved: a registry id
-/// (`minecraft:trial_chamber/breeze/normal`) or an inline config.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct ConfigSlot {
-    /// The value as loaded, written back as is; None for the default.
-    pub saved: Option<Tag>,
-    pub config: TrialConfig,
-}
-/// `TrialSpawner` with its `TrialSpawnerStateData`.
-#[derive(Clone, Debug, PartialEq)]
-pub struct TrialSpawner {
-    pub normal: ConfigSlot,
-    pub ominous: ConfigSlot,
-    pub target_cooldown_length: i32,
-    pub required_player_range: i32,
-    pub detected_players: Vec<Uuid>,
-    pub current_mobs: Vec<Uuid>,
-    pub cooldown_ends_at: i64,
-    pub next_mob_spawns_at: i64,
-    pub total_mobs_spawned: i32,
-    pub next_spawn_data: Option<SpawnData>,
-    pub ejecting_loot_table: Option<String>,
-    /// `isOminous`, set from the block on every server tick.
-    pub is_ominous: bool,
-    /// The server's display entity exists (`getOrCreateDisplayEntity`): it is
-    /// made once per loaded block entity and kept.
-    pub has_display: bool,
-    pub spin: f64,
-    pub o_spin: f64,
-    /// `getDispensingItems`, kept once rolled (not saved): the ominous items
-    /// and their weights (the rolled counts).
-    pub dispensing: Option<Vec<ItemStack>>,
-}
-impl Default for TrialSpawner {
-    fn default() -> Self {
-        Self {
-            normal: ConfigSlot::default(),
-            ominous: ConfigSlot::default(),
-            target_cooldown_length: 36000,
-            required_player_range: 14,
-            detected_players: Vec::new(),
-            current_mobs: Vec::new(),
-            cooldown_ends_at: 0,
-            next_mob_spawns_at: 0,
-            total_mobs_spawned: 0,
-            next_spawn_data: None,
-            ejecting_loot_table: None,
-            is_ominous: false,
-            has_display: false,
-            spin: 0.0,
-            o_spin: 0.0,
-            dispensing: None,
-        }
-    }
-}
-/// `VaultConfig`.
-#[derive(Clone, Debug, PartialEq)]
-pub struct VaultConfig {
-    pub loot_table: String,
-    pub activation_range: f64,
-    pub deactivation_range: f64,
-    /// None when the config has no key (`ItemStack.EMPTY`): the vault never opens.
-    pub key_item: Option<ItemStack>,
-    pub override_loot_table_to_display: Option<String>,
-}
-/// `VaultBlockEntity`: its config, server data and shared data.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Vault {
-    pub config: VaultConfig,
-    /// `VaultServerData`, oldest rewarded player first.
-    pub rewarded_players: Vec<Uuid>,
-    pub state_updating_resumes_at: i64,
-    /// Popped from the end.
-    pub items_to_eject: Vec<ItemStack>,
-    pub total_ejections_needed: i32,
-    pub last_insert_fail_timestamp: i64,
-    /// `VaultSharedData`.
-    pub display_item: Option<ItemStack>,
-    pub connected_players: Vec<Uuid>,
-    pub connected_particles_range: f64,
-    /// The shared data changed since the last tick sent it.
-    pub shared_dirty: bool,
-    /// `VaultClientData`: the display item's spin and the previous tick's, in degrees.
-    pub spin: f32,
-    pub o_spin: f32,
-}
-/// `BeehiveBlockEntity`: the bees inside and the flower one of them knew.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct Beehive {
-    pub bees: Vec<Occupant>,
-    pub flower: Option<[i32; 3]>,
-}
-/// `BeehiveBlockEntity.Occupant`: a bee's tag (with its `id`), its time in
-/// the hive and the time it stays at least.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Occupant {
-    pub entity_data: Tag,
-    pub ticks_in_hive: i32,
-    pub min_ticks_in_hive: i32,
-}
-#[derive(Clone, Debug, PartialEq)]
-pub struct CommandBlock {
-    pub command: String,
-    pub success_count: i32,
-    /// `CustomName` as saved (a text component).
-    pub custom_name: Option<Tag>,
-    pub track_output: bool,
-    pub last_output: Option<Text>,
-    pub update_last_execution: bool,
-    /// The game time of the last run, -1 for none.
-    pub last_execution: i64,
-    pub powered: bool,
-    pub auto: bool,
-    pub condition_met: bool,
-}

crates/horizon-client-render/src/containers.rs

@@ -1,587 +0,0 @@
-//! Container block entities: chests/barrels (27 slots) and the three furnace
-//! kinds, ticking as `AbstractFurnaceBlockEntity.serverTick` with fuel times
-//! from the data-driven `context_int_provider`/`context_float_provider` files.
-pub use crate::chunk::block_entity::{
-    Banner, Beacon, BlockEntity, Brushable, Campfire, ChiseledBookshelf, Crafter, CreakingHeart,
-    EndGateway, Furnace, FurnaceKind, Jukebox, Lectern, PotentSulfur, Shelf, Skull, SkullSkin,
-};
-use crate::items::ItemStack;
-use std::collections::HashMap;
-
-impl FurnaceKind {
-    pub fn recipe_type(self) -> &'static str {
-        match self {
-            Self::Furnace => "minecraft:smelting",
-            Self::BlastFurnace => "minecraft:blasting",
-            Self::Smoker => "minecraft:smoking",
-        }
-    }
-    pub fn fast(self) -> bool {
-        self != Self::Furnace
-    }
-    pub fn from_block(name: &str) -> Option<Self> {
-        match name {
-            "minecraft:furnace" => Some(Self::Furnace),
-            "minecraft:blast_furnace" => Some(Self::BlastFurnace),
-            "minecraft:smoker" => Some(Self::Smoker),
-            _ => None,
-        }
-    }
-}
-/// The key `recipes_used` keeps a recipe under: its full id, as vanilla's `ResourceKey<Recipe>`
-/// writes it in `RecipesUsed`. Horizon's own recipe ids are file names without the namespace, so
-/// keeping both forms would write a key twice, and vanilla refuses such a furnace
-/// ("Duplicate entry for key").
-pub fn recipe_used_key(id: &str) -> String {
-    if id.contains(':') {
-        id.to_owned()
-    } else {
-        format!("minecraft:{id}")
-    }
-}
-/// A hopper's slots: the only plain container with five.
-pub const HOPPER_SLOTS: usize = 5;
-
-/// `getDefaultName` of the `BaseContainerBlockEntity` that `block` holds: the
-/// translation key of its menu's title when it has no custom name. Copper
-/// chests hold a `ChestBlockEntity`, shulker boxes of every colour a
-/// `ShulkerBoxBlockEntity`.
-pub fn default_name_key(block: &str) -> Option<&'static str> {
-    Some(match block {
-        "minecraft:chest" | "minecraft:trapped_chest" => "container.chest",
-        n if n.ends_with("copper_chest") => "container.chest",
-        "minecraft:barrel" => "container.barrel",
-        n if n.ends_with("shulker_box") => "container.shulkerBox",
-        "minecraft:dispenser" => "container.dispenser",
-        "minecraft:dropper" => "container.dropper",
-        "minecraft:hopper" => "container.hopper",
-        "minecraft:furnace" => "container.furnace",
-        "minecraft:smoker" => "container.smoker",
-        "minecraft:blast_furnace" => "container.blast_furnace",
-        "minecraft:brewing_stand" => "container.brewing",
-        "minecraft:crafter" => "container.crafter",
-        _ => return None,
-    })
-}
-
-/// `BaseContainerBlockEntity.getDisplayName` (`getName`), the title of the
-/// `ClientboundOpenScreenPacket` that opens it: the block entity's custom
-/// name (`CustomName`, a literal), else its default name.
-pub fn display_name(custom: Option<&str>, default_key: &str) -> horizon_world::nbt::Tag {
-    match custom {
-        Some(name) => horizon_protocol::text::literal(name),
-        None => horizon_protocol::text::translatable(default_key, &[]),
-    }
-}
-
-/// `ChestBlock.MENU_PROVIDER_COMBINER`'s `getDisplayName` for a double chest:
-/// the first half's custom name (the right half, `DoubleBlockCombiner`'s
-/// `FIRST`), else the second's, else `container.chestDouble`.
-pub fn double_chest_name(first: Option<&str>, second: Option<&str>) -> horizon_world::nbt::Tag {
-    display_name(first.or(second), "container.chestDouble")
-}
-
-impl Campfire {
-    /// `placeFood`'s slot: the first empty one, given the item's
-    /// `campfire_cooking` time; it takes one item of `held`.
-    pub fn place_food(&mut self, held: &mut ItemStack, cooking_time: i32) -> bool {
-        let Some(slot) = self.items.iter().position(Option::is_none) else {
-            return false;
-        };
-        self.total[slot] = cooking_time;
-        self.progress[slot] = 0;
-        self.items[slot] = Some(ItemStack {
-            count: 1,
-            ..held.clone()
-        });
-        held.count = held.count.saturating_sub(1);
-        true
-    }
-    /// `cookTick` (lit): each item's progress rises by one; the slots whose
-    /// progress reached their cooking time give up their item (the caller
-    /// drops its result).
-    pub fn cook_tick(&mut self) -> Vec<(usize, ItemStack)> {
-        let mut done = Vec::new();
-        for i in 0..4 {
-            if self.items[i].is_none() {
-                continue;
-            }
-            self.progress[i] += 1;
-            if self.progress[i] >= self.total[i]
-                && let Some(item) = self.items[i].take()
-            {
-                done.push((i, item));
-            }
-        }
-        done
-    }
-    /// `cooldownTick` (unlit): the progress falls by two, no lower than 0.
-    /// Whether anything changed (`setChanged`).
-    pub fn cooldown_tick(&mut self) -> bool {
-        let mut changed = false;
-        for i in 0..4 {
-            if self.progress[i] > 0 {
-                changed = true;
-                self.progress[i] = (self.progress[i] - 2).clamp(0, self.total[i]);
-            }
-        }
-        changed
-    }
-}
-impl Skull {
-    pub fn new(
-        profile: Option<horizon_world::nbt::Tag>,
-        note_block_sound: Option<String>,
-        custom_name: Option<horizon_world::nbt::Tag>,
-    ) -> Self {
-        let skin = profile.as_ref().map(SkullSkin::of);
-        Self {
-            profile,
-            note_block_sound,
-            custom_name,
-            skin,
-        }
-    }
-}
-impl SkullSkin {
-    pub fn of(profile: &horizon_world::nbt::Tag) -> Self {
-        let download = crate::skins::profile_skin_url_nbt(profile).and_then(|url| {
-            let location = crate::skins::skin_location(&crate::skins::texture_hash(&url)?);
-            Some((url, location))
-        });
-        // A `Dynamic` profile (a name or id only) resolves through the
-        // services when the skull is drawn.
-        let dynamic = crate::skins::dynamic_nbt(profile);
-        // DefaultPlayerSkin.get(id), or getDefaultSkin (slim steve) without an id.
-        let fallback = crate::skins::profile_uuid_nbt(profile)
-            .or_else(|| {
-                crate::skins::nbt_text(profile.get("name"))
-                    .map(|name| horizon_protocol::crypto::offline_uuid(&name))
-            })
-            .map_or("entity/player/slim/steve", crate::tab_list::default_skin);
-        Self {
-            download,
-            dynamic,
-            fallback,
-        }
-    }
-}
-/// The skull and head blocks (`SkullBlock`, `WallSkullBlock`): every
-/// `*_skull` and `*_head` but the piston's head.
-fn is_skull(name: &str) -> bool {
-    name.ends_with("_skull") || (name.ends_with("_head") && name != "minecraft:piston_head")
-}
-impl Crafter {
-    /// `slotCanBeDisabled`: only empty slots.
-    pub fn slot_can_be_disabled(&self, slot: usize) -> bool {
-        slot < 9 && self.items[slot].is_none()
-    }
-    /// `setSlotState`.
-    pub fn set_slot_state(&mut self, slot: usize, enabled: bool) {
-        if self.slot_can_be_disabled(slot) {
-            self.disabled[slot] = !enabled;
-        }
-    }
-    /// `getRedstoneSignal`: filled or disabled slots.
-    pub fn redstone_signal(&self) -> i32 {
-        (0..9)
-            .filter(|&i| self.items[i].is_some() || self.disabled[i])
-            .count() as i32
-    }
-    /// `canPlaceItem`: a hopper fills the smallest stacks first.
-    pub fn can_place(&self, slot: usize, _stack: &ItemStack, max_stack: u32) -> bool {
-        if slot >= 9 || self.disabled[slot] {
-            return false;
-        }
-        let Some(current) = &self.items[slot] else {
-            return true;
-        };
-        if current.count >= max_stack {
-            return false;
-        }
-        !(slot + 1..9).any(|i| {
-            !self.disabled[i]
-                && match &self.items[i] {
-                    None => true,
-                    Some(other) => {
-                        other.count < current.count && other.same_item_same_components(current)
-                    }
-                }
-        })
-    }
-}
-impl BlockEntity {
-    pub fn for_block(name: &str) -> Option<Self> {
-        if let Some(hanging) = crate::signs::sign_kind(name) {
-            return Some(Self::Sign(crate::signs::SignData {
-                hanging,
-                ..Default::default()
-            }));
-        }
-        if let Some(kind) = FurnaceKind::from_block(name) {
-            return Some(Self::Furnace(Furnace {
-                kind,
-                items: [None, None, None],
-                lit_remaining: 0,
-                lit_total: 0,
-                cooking_timer: 0,
-                cooking_total: 0,
-                speed: 1.0,
-                recipes_used: HashMap::new(),
-            }));
-        }
-        if matches!(
-            name,
-            "minecraft:suspicious_sand"
-                | "minecraft:suspicious_gravel"
-                | "minecraft:brushable_block"
-        ) {
-            return Some(Self::Brushable(Box::default()));
-        }
-        if name == "minecraft:creaking_heart" {
-            return Some(Self::CreakingHeart(Box::default()));
-        }
-        if name == "minecraft:spawner" {
-            return Some(Self::Spawner(Box::default()));
-        }
-        if name == "minecraft:trial_spawner" {
-            return Some(Self::TrialSpawner(Box::default()));
-        }
-        if name == "minecraft:vault" {
-            return Some(Self::Vault(Box::default()));
-        }
-        if name == "minecraft:beehive" || name == "minecraft:bee_nest" {
-            return Some(Self::Beehive(Box::default()));
-        }
-        if name == "minecraft:lectern" {
-            return Some(Self::Lectern(Lectern::default()));
-        }
-        if crate::command_block::Mode::of_block(name).is_some() {
-            // CommandBlock.newBlockEntity: setAutomatic(this.automatic).
-            return Some(Self::CommandBlock(Box::new(
-                crate::command_block::CommandBlock {
-                    auto: crate::command_block::automatic_block(name),
-                    ..Default::default()
-                },
-            )));
-        }
-        if let Some(sculk) = crate::sculk::SculkEntity::for_block(name) {
-            return Some(Self::Sculk(Box::new(sculk)));
-        }
-        if name == "minecraft:crafter" {
-            // CrafterBlock.newBlockEntity copies the placed state's flag: the
-            // first tick sees it as a change from untriggered.
-            return Some(Self::Crafter(Crafter {
-                state_triggered: Some(false),
-                ..Crafter::default()
-            }));
-        }
-        if name.ends_with("_banner") {
-            return Some(Self::Banner(Banner::default()));
-        }
-        if is_skull(name) {
-            return Some(Self::Skull(Skull::default()));
-        }
-        if name == "minecraft:end_gateway" {
-            return Some(Self::EndGateway(EndGateway::default()));
-        }
-        if name == "minecraft:daylight_detector" {
-            return Some(Self::DaylightDetector);
-        }
-        if name == "minecraft:beacon" {
-            return Some(Self::Beacon(Box::new(Beacon {
-                last_check_y: i32::MIN / 2,
-                ..Default::default()
-            })));
-        }
-        if name == "minecraft:brewing_stand" {
-            return Some(Self::Brewing(Box::new(crate::brewing::BrewingStand::new())));
-        }
-        if name == "minecraft:campfire" || name == "minecraft:soul_campfire" {
-            return Some(Self::Campfire(Box::default()));
-        }
-        if name == "minecraft:shelf" || name.ends_with("_shelf") {
-            return Some(Self::Shelf(Box::default()));
-        }
-        if name == "minecraft:chiseled_bookshelf" {
-            return Some(Self::ChiseledBookshelf(Box::default()));
-        }
-        if name == "minecraft:potent_sulfur" {
-            return Some(Self::PotentSulfur(PotentSulfur::default()));
-        }
-        let size = match name {
-            "minecraft:chest" | "minecraft:trapped_chest" | "minecraft:barrel" => 27,
-            n if n.ends_with("copper_chest") => 27,
-            "minecraft:hopper" => HOPPER_SLOTS,
-            "minecraft:dispenser" | "minecraft:dropper" => 9,
-            n if n.ends_with("shulker_box") => 27,
-            _ => return None,
-        };
-        Some(Self::Chest(vec![None; size]))
-    }
-    pub fn id(&self) -> &'static str {
-        match self {
-            Self::Chest(items) => match items.len() {
-                HOPPER_SLOTS => "minecraft:hopper",
-                9 => "minecraft:dispenser",
-                _ => "minecraft:chest",
-            },
-            Self::Furnace(f) => match f.kind {
-                FurnaceKind::Furnace => "minecraft:furnace",
-                FurnaceKind::BlastFurnace => "minecraft:blast_furnace",
-                FurnaceKind::Smoker => "minecraft:smoker",
-            },
-            Self::Brewing(_) => "minecraft:brewing_stand",
-            Self::Sign(s) => s.id(),
-            Self::Jukebox(_) => "minecraft:jukebox",
-            Self::Beacon(_) => "minecraft:beacon",
-            Self::Lectern(_) => "minecraft:lectern",
-            Self::Sculk(s) => s.id(),
-            Self::Banner(_) => "minecraft:banner",
-            Self::Crafter(_) => "minecraft:crafter",
-            Self::CreakingHeart(_) => "minecraft:creaking_heart",
-            Self::Spawner(_) => "minecraft:mob_spawner",
-            Self::TrialSpawner(_) => "minecraft:trial_spawner",
-            Self::Vault(_) => "minecraft:vault",
-            Self::Beehive(_) => "minecraft:beehive",
-            Self::CommandBlock(_) => "minecraft:command_block",
-            Self::Skull(_) => "minecraft:skull",
-            Self::EndGateway(_) => "minecraft:end_gateway",
-            Self::DaylightDetector => "minecraft:daylight_detector",
-            Self::Brushable(_) => "minecraft:brushable_block",
-            Self::Campfire(_) => "minecraft:campfire",
-            Self::ChiseledBookshelf(_) => "minecraft:chiseled_bookshelf",
-            Self::Shelf(_) => "minecraft:shelf",
-            Self::PotentSulfur(_) => "minecraft:potent_sulfur",
-        }
-    }
-    pub fn contents(&self) -> Vec<ItemStack> {
-        match self {
-            Self::Chest(items) => items.iter().flatten().cloned().collect(),
-            Self::Furnace(f) => f.items.iter().flatten().cloned().collect(),
-            Self::Brewing(b) => b.items.iter().flatten().cloned().collect(),
-            Self::Sign(_) => Vec::new(),
-            Self::Jukebox(j) => j.record.iter().cloned().collect(),
-            Self::Beacon(_)
-            | Self::CreakingHeart(_)
-            | Self::Spawner(_)
-            | Self::TrialSpawner(_)
-            | Self::Vault(_)
-            | Self::Beehive(_)
-            | Self::CommandBlock(_)
-            | Self::EndGateway(_)
-            | Self::Skull(_)
-            | Self::PotentSulfur(_)
-            | Self::DaylightDetector
-            | Self::Brushable(_) => Vec::new(),
-            Self::Lectern(l) => l.book.iter().cloned().collect(),
-            Self::Sculk(_) => Vec::new(),
-            Self::Banner(_) => Vec::new(),
-            Self::Crafter(c) => c.items.iter().flatten().cloned().collect(),
-            Self::Campfire(c) => c.items.iter().flatten().cloned().collect(),
-            Self::ChiseledBookshelf(b) => b.items.iter().flatten().cloned().collect(),
-            Self::Shelf(b) => b.items.iter().flatten().cloned().collect(),
-        }
-    }
-    pub fn slots(&self) -> &[Option<ItemStack>] {
-        match self {
-            Self::Chest(items) => items,
-            Self::Furnace(f) => &f.items,
-            Self::Brewing(b) => &b.items,
-            Self::Sign(_)
-            | Self::Jukebox(_)
-            | Self::Beacon(_)
-            | Self::Lectern(_)
-            | Self::Sculk(_)
-            | Self::Banner(_)
-            | Self::EndGateway(_)
-            | Self::Skull(_)
-            | Self::PotentSulfur(_)
-            | Self::DaylightDetector
-            | Self::Brushable(_) => &[],
-            Self::Crafter(c) => &c.items,
-            Self::ChiseledBookshelf(b) => &b.items,
-            Self::Shelf(b) => &b.items,
-            Self::CreakingHeart(_)
-            | Self::Spawner(_)
-            | Self::TrialSpawner(_)
-            | Self::Vault(_)
-            | Self::Beehive(_)
-            | Self::CommandBlock(_)
-            // Not a Container (only Clearable): hoppers don't reach in.
-            | Self::Campfire(_) => &[],
-        }
-    }
-    pub fn slots_mut(&mut self) -> &mut [Option<ItemStack>] {
-        match self {
-            Self::Chest(items) => items,
-            Self::Furnace(f) => &mut f.items,
-            Self::Brewing(b) => &mut b.items,
-            Self::Sign(_)
-            | Self::Jukebox(_)
-            | Self::Beacon(_)
-            | Self::Lectern(_)
-            | Self::Sculk(_)
-            | Self::Banner(_)
-            | Self::EndGateway(_)
-            | Self::Skull(_)
-            | Self::PotentSulfur(_)
-            | Self::DaylightDetector
-            | Self::Brushable(_) => &mut [],
-            Self::Crafter(c) => &mut c.items,
-            Self::ChiseledBookshelf(b) => &mut b.items,
-            Self::Shelf(b) => &mut b.items,
-            Self::CreakingHeart(_)
-            | Self::Spawner(_)
-            | Self::TrialSpawner(_)
-            | Self::Vault(_)
-            | Self::Beehive(_)
-            | Self::CommandBlock(_)
-            | Self::Campfire(_) => &mut [],
-        }
-    }
-}
-pub use crate::providers::Providers;
-
-/// A `ChestBlock`, which `ChestBlock.combine` can join into a double chest:
-/// chests, trapped chests and copper chests in every weathering state, waxed
-/// or not (`CopperChestBlock` extends `ChestBlock`). Ender chests are
-/// `EnderChestBlock`s and always single.
-pub fn is_chest_block(name: &str) -> bool {
-    matches!(name, "minecraft:chest" | "minecraft:trapped_chest") || name.ends_with("copper_chest")
-}
-
-/// A chest block's name with its `type` and `facing` properties.
-#[derive(Clone, Copy, Debug)]
-pub struct ChestHalf<'a> {
-    pub block: &'a str,
-    pub kind: &'a str,
-    pub facing: &'a str,
-}
-
-impl ChestHalf<'_> {
-    /// `ChestBlock.getConnectedDirection` as an (x, z) step to the other
-    /// half: clockwise from the facing for a left half, counter-clockwise for
-    /// a right one. None for a single chest.
-    pub fn connected_step(&self) -> Option<(i32, i32)> {
-        let step = |facing: &str| match facing {
-            "north" => Some((0, -1)),
-            "south" => Some((0, 1)),
-            "west" => Some((-1, 0)),
-            "east" => Some((1, 0)),
-            _ => None,
-        };
-        let (x, z) = step(self.facing)?;
-        // Turning clockwise seen from above takes (x, z) to (-z, x).
-        match self.kind {
-            "left" => Some((-z, x)),
-            "right" => Some((z, -x)),
-            _ => None,
-        }
-    }
-
-    /// `DoubleBlockCombiner.combineWithNeigbour` as `ChestBlock.combine` calls
-    /// it: `other`, the block in this half's connected direction, is its other
-    /// half when it is the same block, a half of the other side and faces the
-    /// same way. Copper chests in different weathering states never join
-    /// (`CopperChestBlock` keeps both halves in one state instead).
-    pub fn pairs_with(&self, other: &ChestHalf) -> bool {
-        is_chest_block(self.block)
-            && self.kind != "single"
-            && other.block == self.block
-            && other.kind != "single"
-            && other.kind != self.kind
-            && other.facing == self.facing
-    }
-}
-
-/// `AbstractFurnaceBlockEntity.createExperience`: `count * experience`, floored, and one
-/// more with the chance of what is left over (a level random draw only when there is some).
-pub fn create_experience(
-    count: u32,
-    experience: f32,
-    random: &mut impl horizon_core::random::RandomSource,
-) -> u32 {
-    let total = count as f32 * experience;
-    let whole = total.floor();
-    let fraction = total - whole;
-    let mut xp = whole.max(0.0) as u32;
-    if fraction != 0.0 && random.next_float() < fraction {
-        xp += 1;
-    }
-    xp
-}
-
-/// The `MenuType` the block entity of a one-block storage container opens
-/// (`createMenu`): `ChestMenu.threeRows` for chests, trapped and copper chests
-/// and barrels, `ShulkerBoxMenu` for shulker boxes of any colour (its
-/// `ShulkerBoxSlot`s refuse shulker boxes), `DispenserMenu` for dispensers
-/// and droppers, `HopperMenu` for hoppers. None for other blocks.
-pub fn block_menu_type(block: &str) -> Option<&'static str> {
-    Some(match block {
-        "minecraft:chest" | "minecraft:trapped_chest" | "minecraft:barrel" => {
-            "minecraft:generic_9x3"
-        }
-        n if n.ends_with("copper_chest") => "minecraft:generic_9x3",
-        n if n.ends_with("shulker_box") => "minecraft:shulker_box",
-        "minecraft:dispenser" | "minecraft:dropper" => "minecraft:generic_3x3",
-        "minecraft:hopper" => "minecraft:hopper",
-        _ => return None,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use horizon_core::random::{LegacyRandom, RandomSource};
-
-    #[test]
-    fn campfire_slots_take_food_cook_it_and_cool_down() {
-        let mut c = Campfire::default();
-        let mut beef = ItemStack::new("minecraft:beef", 2);
-        // placeFood: the first free slot, one item, its recipe's time.
-        assert!(c.place_food(&mut beef, 600));
-        assert_eq!(beef.count, 1);
-        assert_eq!(c.items[0].as_ref().map(|s| s.count), Some(1));
-        assert_eq!((c.progress[0], c.total[0]), (0, 600));
-        let mut fish = ItemStack::new("minecraft:cod", 1);
-        assert!(c.place_food(&mut fish, 3));
-        assert_eq!(c.items[1].as_ref().map(|s| &*s.item), Some("minecraft:cod"));
-        // cookTick: the cod is done on its third tick, the beef keeps cooking.
-        assert!(c.cook_tick().is_empty());
-        assert!(c.cook_tick().is_empty());
-        let done = c.cook_tick();
-        assert_eq!(done.len(), 1);
-        assert_eq!((done[0].0, &*done[0].1.item), (1, "minecraft:cod"));
-        assert!(c.items[1].is_none());
-        assert_eq!(c.progress[0], 3);
-        // cooldownTick: two a tick, never below zero.
-        assert!(c.cooldown_tick());
-        assert_eq!(c.progress[0], 1);
-        assert!(c.cooldown_tick());
-        assert_eq!(c.progress[0], 0);
-        // Full: four slots, no fifth.
-        for _ in 0..3 {
-            let mut more = ItemStack::new("minecraft:potato", 1);
-            assert!(c.place_food(&mut more, 600));
-        }
-        let mut fifth = ItemStack::new("minecraft:potato", 1);
-        assert!(!c.place_food(&mut fifth, 600));
-        assert_eq!(fifth.count, 1);
-    }
-
-    /// A whole amount pays itself without a draw; a fraction is a chance of one more.
-    #[test]
-    fn create_experience_rounds_the_fraction_by_chance() {
-        let mut random = LegacyRandom::new(7);
-        let mut untouched = LegacyRandom::new(7);
-        assert_eq!(create_experience(4, 0.5, &mut random), 2);
-        assert_eq!(create_experience(3, 0.0, &mut random), 0);
-        assert_eq!(random.next_long(), untouched.next_long());
-        let paid: u32 = (0..1000)
-            .map(|_| create_experience(1, 0.35, &mut random))
-            .sum();
-        assert!((250..450).contains(&paid), "{paid}");
-        assert!((0..100).all(|_| (1..=2).contains(&create_experience(1, 1.7, &mut random))));
-    }
-}

crates/horizon-client-render/src/gfx/compositor.rs

@@ -1,214 +0,0 @@
-//! Splitscreen: several players' renderers draw offscreen on one device, and the
-//! compositor copies each frame into its place on a window's surface. A window holds views but
-//! never owns them, so a view can later move to another window (another monitor, detached).
-use super::Renderer;
-use crate::Result;
-use std::sync::Arc;
-use winit::window::Window;
-
-pub struct Compositor {
-    surface: wgpu::Surface<'static>,
-    device: wgpu::Device,
-    queue: wgpu::Queue,
-    config: wgpu::SurfaceConfiguration,
-    present_modes: Vec<wgpu::PresentMode>,
-    suspended: bool,
-}
-
-impl Renderer {
-    /// A compositor for `window` on this renderer's device, presenting on the surface it gave up.
-    pub fn compositor(&self, window: Arc<Window>) -> Result<Compositor> {
-        // The surface this renderer set aside for its successor (`release_surface`), else a new
-        // one: a window can't keep two.
-        let spare = self
-            .spare_surface
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner)
-            .take();
-        let surface = match spare {
-            Some(surface) => surface,
-            None => self.instance.create_surface(window.clone())?,
-        };
-        Compositor::new(
-            surface,
-            &self.adapter,
-            &self.device,
-            &self.queue,
-            window.inner_size().into(),
-        )
-    }
-
-    /// The last offscreen frame (`--offscreen`), for the compositor.
-    pub fn offscreen_frame(&self) -> Option<&wgpu::Texture> {
-        self.offscreen.as_ref()
-    }
-
-    /// Splitscreen turned off: a compositor's surface, set aside for the renderer that draws on
-    /// the window again (it takes it, as after `release_surface`).
-    pub fn take_back(&self, compositor: Compositor) {
-        *self
-            .spare_surface
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(compositor.surface);
-    }
-}
-
-impl Compositor {
-    /// Present offscreen BGRA frames on a compatible surface using their existing device.
-    /// The surface must support COPY_DST and Bgra8Unorm; unsupported surfaces return an error.
-    pub fn new(
-        surface: wgpu::Surface<'static>,
-        adapter: &wgpu::Adapter,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        size: [u32; 2],
-    ) -> Result<Self> {
-        let caps = surface.get_capabilities(adapter);
-        // ponytail: a plain texture copy needs the offscreen frames' format; a blit pass would
-        // take any surface format (Rgba8Unorm on some Linux drivers).
-        if !caps.usages.contains(wgpu::TextureUsages::COPY_DST) {
-            return Err("surface does not support copying offscreen frames".into());
-        }
-        let format = wgpu::TextureFormat::Bgra8Unorm;
-        if !caps.formats.contains(&format) {
-            return Err(format!(
-                "splitscreen needs a {format:?} surface; this one offers {:?}",
-                caps.formats
-            )
-            .into());
-        }
-        let max = device.limits().max_texture_dimension_2d;
-        let config = wgpu::SurfaceConfiguration {
-            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST,
-            format,
-            width: size[0].clamp(1, max),
-            height: size[1].clamp(1, max),
-            present_mode: wgpu::PresentMode::Fifo,
-            desired_maximum_frame_latency: 2,
-            alpha_mode: wgpu::CompositeAlphaMode::Opaque,
-            view_formats: vec![],
-            color_space: wgpu::SurfaceColorSpace::default(),
-        };
-        surface.configure(device, &config);
-        Ok(Compositor {
-            surface,
-            device: device.clone(),
-            queue: queue.clone(),
-            config,
-            present_modes: caps.present_modes,
-            suspended: !super::drawable_size(size[0], size[1], max),
-        })
-    }
-
-    /// Vsync on: presents wait for the display. Off: they don't (Mailbox, else Immediate).
-    pub fn set_vsync(&mut self, vsync: bool) {
-        let mode = [wgpu::PresentMode::Mailbox, wgpu::PresentMode::Immediate]
-            .into_iter()
-            .find(|m| !vsync && self.present_modes.contains(m))
-            .unwrap_or(wgpu::PresentMode::Fifo);
-        if mode != self.config.present_mode {
-            self.config.present_mode = mode;
-            self.surface.configure(&self.device, &self.config);
-        }
-    }
-
-    pub fn resize(&mut self, width: u32, height: u32) {
-        self.suspended =
-            !super::drawable_size(width, height, self.device.limits().max_texture_dimension_2d);
-        if !self.suspended {
-            self.config.width = width;
-            self.config.height = height;
-            self.surface.configure(&self.device, &self.config);
-        }
-    }
-
-    /// Copy each view's frame to its top-left corner on the window and present. Frames that
-    /// don't fit are clipped; parts of the window no view covers (a view before its first frame,
-    /// one still at its old size after a resize) are black. Nothing when the window has no frame
-    /// to give (occluded, resized, timed out). Returns true when a frame was submitted.
-    pub fn present(&mut self, views: &[(&wgpu::Texture, [u32; 2])]) -> bool {
-        if self.suspended {
-            return false;
-        }
-        let frame = match self.surface.get_current_texture() {
-            wgpu::CurrentSurfaceTexture::Success(f)
-            | wgpu::CurrentSurfaceTexture::Suboptimal(f) => f,
-            wgpu::CurrentSurfaceTexture::Outdated | wgpu::CurrentSurfaceTexture::Lost => {
-                self.surface.configure(&self.device, &self.config);
-                return false;
-            }
-            _ => return false,
-        };
-        let mut encoder = self
-            .device
-            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
-                label: Some("Splitscreen compositor"),
-            });
-        let target = frame.texture.create_view(&Default::default());
-        drop(encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-            label: Some("Splitscreen compositor clear"),
-            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                view: &target,
-                depth_slice: None,
-                resolve_target: None,
-                ops: wgpu::Operations {
-                    load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
-                    store: wgpu::StoreOp::Store,
-                },
-            })],
-            ..Default::default()
-        }));
-        for &(texture, [x, y]) in views {
-            let [width, height] = clipped_size(
-                [texture.width(), texture.height()],
-                [x, y],
-                [self.config.width, self.config.height],
-            );
-            if width == 0 || height == 0 {
-                continue;
-            }
-            encoder.copy_texture_to_texture(
-                texture.as_image_copy(),
-                wgpu::TexelCopyTextureInfo {
-                    origin: wgpu::Origin3d { x, y, z: 0 },
-                    ..frame.texture.as_image_copy()
-                },
-                wgpu::Extent3d {
-                    width,
-                    height,
-                    depth_or_array_layers: 1,
-                },
-            );
-        }
-        self.queue.submit([encoder.finish()]);
-        self.queue.present(frame);
-        true
-    }
-}
-
-/// Copies never reach past the surface, including while a resized view still has its old frame.
-fn clipped_size(view: [u32; 2], at: [u32; 2], surface: [u32; 2]) -> [u32; 2] {
-    [
-        view[0].min(surface[0].saturating_sub(at[0])),
-        view[1].min(surface[1].saturating_sub(at[1])),
-    ]
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn frames_are_clipped_to_the_window_during_resize() {
-        assert_eq!(clipped_size([640, 480], [0, 0], [1280, 720]), [640, 480]);
-        assert_eq!(
-            clipped_size([640, 480], [1000, 600], [1280, 720]),
-            [280, 120]
-        );
-        assert_eq!(clipped_size([640, 480], [1280, 720], [1280, 720]), [0, 0]);
-        assert_eq!(
-            clipped_size([640, 480], [u32::MAX, 0], [1280, 720]),
-            [0, 480]
-        );
-    }
-}

crates/horizon-client-render/src/gfx/entity_outline.rs

@@ -1,311 +0,0 @@
-//! The entity outline (`LevelRenderer.entityOutlineTarget`): the glowing entities'
-//! silhouettes in their team colours, drawn without depth so walls do not hide them
-//! (`RenderTypes.outline`), the `entity_outline` post chain over them (`entity_sobel`, then
-//! `entity_outline_box_blur` across and up), and `LevelRenderer.blitEntityOutline` onto
-//! the frame after the hand.
-use super::Vertex;
-
-/// `entityOutlineTarget`'s `GpuFormat.RGBA8_UNORM`.
-const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
-
-struct Targets {
-    size: [u32; 2],
-    /// `entityOutlineTarget`.
-    outline: wgpu::TextureView,
-    /// The chain's `swap` target.
-    swap: wgpu::TextureView,
-    /// What each pass reads: the outline (nearest), swap (bilinear), the outline
-    /// (bilinear), swap (nearest).
-    groups: [wgpu::BindGroup; 4],
-}
-
-pub(super) struct EntityOutline {
-    silhouette: wgpu::RenderPipeline,
-    /// Sobel, blur across, blur up (into `FORMAT`) and the blended blit (onto the frame).
-    passes: [wgpu::RenderPipeline; 4],
-    layout: wgpu::BindGroupLayout,
-    nearest: wgpu::Sampler,
-    bilinear: wgpu::Sampler,
-    vertices: wgpu::Buffer,
-    capacity: u64,
-    quads: u32,
-    targets: Option<Targets>,
-}
-
-impl EntityOutline {
-    /// `entity` draws the silhouettes with the entity shader's vertex stage and
-    /// `fs_outline`; `format` is the frame's.
-    pub(super) fn new(
-        device: &wgpu::Device,
-        entity: (
-            &wgpu::ShaderModule,
-            &wgpu::PipelineLayout,
-            &[Option<wgpu::VertexBufferLayout>],
-        ),
-        format: wgpu::TextureFormat,
-    ) -> Self {
-        let (entity_shader, entity_layout, entity_vertex) = entity;
-        // RenderPipelines.OUTLINE_NO_CULL: no depth test, the colour replaced.
-        let silhouette = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-            label: Some("Entity outline silhouettes"),
-            layout: Some(entity_layout),
-            vertex: wgpu::VertexState {
-                module: entity_shader,
-                entry_point: Some("vs_entity"),
-                compilation_options: Default::default(),
-                buffers: entity_vertex,
-            },
-            primitive: Default::default(),
-            depth_stencil: None,
-            multisample: Default::default(),
-            fragment: Some(wgpu::FragmentState {
-                module: entity_shader,
-                entry_point: Some("fs_outline"),
-                compilation_options: Default::default(),
-                targets: &[Some(FORMAT.into())],
-            }),
-            multiview_mask: None,
-            cache: None,
-        });
-        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-            label: Some("Entity outline"),
-            source: wgpu::ShaderSource::Wgsl(include_str!("entity_outline.wgsl").into()),
-        });
-        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-            label: Some("Entity outline bindings"),
-            entries: &[
-                wgpu::BindGroupLayoutEntry {
-                    binding: 0,
-                    visibility: wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Texture {
-                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
-                        view_dimension: wgpu::TextureViewDimension::D2,
-                        multisampled: false,
-                    },
-                    count: None,
-                },
-                wgpu::BindGroupLayoutEntry {
-                    binding: 1,
-                    visibility: wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
-                    count: None,
-                },
-            ],
-        });
-        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-            label: Some("Entity outline"),
-            bind_group_layouts: &[Some(&layout)],
-            ..Default::default()
-        });
-        let pass = |entry: &str, target: wgpu::ColorTargetState| {
-            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                label: Some(entry),
-                layout: Some(&pipeline_layout),
-                vertex: wgpu::VertexState {
-                    module: &shader,
-                    entry_point: Some("vs_quad"),
-                    compilation_options: Default::default(),
-                    buffers: &[],
-                },
-                primitive: Default::default(),
-                depth_stencil: None,
-                multisample: Default::default(),
-                fragment: Some(wgpu::FragmentState {
-                    module: &shader,
-                    entry_point: Some(entry),
-                    compilation_options: Default::default(),
-                    targets: &[Some(target)],
-                }),
-                multiview_mask: None,
-                cache: None,
-            })
-        };
-        // BlendFunction.ENTITY_OUTLINE_BLIT over the colour only (write mask 7).
-        let blit = wgpu::ColorTargetState {
-            format,
-            blend: Some(wgpu::BlendState {
-                color: wgpu::BlendComponent {
-                    src_factor: wgpu::BlendFactor::SrcAlpha,
-                    dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                    operation: wgpu::BlendOperation::Add,
-                },
-                alpha: wgpu::BlendComponent {
-                    src_factor: wgpu::BlendFactor::Zero,
-                    dst_factor: wgpu::BlendFactor::One,
-                    operation: wgpu::BlendOperation::Add,
-                },
-            }),
-            write_mask: wgpu::ColorWrites::COLOR,
-        };
-        let sampler = |label, filter| {
-            device.create_sampler(&wgpu::SamplerDescriptor {
-                label: Some(label),
-                mag_filter: filter,
-                min_filter: filter,
-                ..Default::default()
-            })
-        };
-        Self {
-            silhouette,
-            passes: [
-                pass("fs_sobel", FORMAT.into()),
-                pass("fs_blur_x", FORMAT.into()),
-                pass("fs_blur_y", FORMAT.into()),
-                pass("fs_blit", blit),
-            ],
-            layout,
-            nearest: sampler("Entity outline nearest", wgpu::FilterMode::Nearest),
-            bilinear: sampler("Entity outline bilinear", wgpu::FilterMode::Linear),
-            vertices: Self::vertex_buffer(device, 256),
-            capacity: 256,
-            quads: 0,
-            targets: None,
-        }
-    }
-
-    fn vertex_buffer(device: &wgpu::Device, capacity: u64) -> wgpu::Buffer {
-        device.create_buffer(&wgpu::BufferDescriptor {
-            label: Some("Entity outline vertices"),
-            size: capacity * std::mem::size_of::<Vertex>() as u64,
-            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
-            mapped_at_creation: false,
-        })
-    }
-
-    /// Uploads this frame's silhouettes (`LevelRenderer.currentFrameRendersEntityOutline`
-    /// when there are any) and sizes the targets like the window.
-    pub(super) fn prepare(
-        &mut self,
-        device: &wgpu::Device,
-        uploads: &mut super::upload::Uploads,
-        encoder: &mut wgpu::CommandEncoder,
-        silhouettes: &[Vertex],
-        size: [u32; 2],
-    ) {
-        self.quads = (silhouettes.len() / 4) as u32;
-        if self.quads == 0 {
-            return;
-        }
-        let vertices = silhouettes.len() as u64;
-        if vertices > self.capacity {
-            self.capacity = vertices.next_power_of_two();
-            self.vertices = Self::vertex_buffer(device, self.capacity);
-        }
-        uploads.buffer(
-            encoder,
-            &self.vertices,
-            0,
-            bytemuck::cast_slice(silhouettes),
-        );
-        if self.targets.as_ref().is_some_and(|t| t.size == size) {
-            return;
-        }
-        let texture = |label| {
-            device
-                .create_texture(&wgpu::TextureDescriptor {
-                    label: Some(label),
-                    size: wgpu::Extent3d {
-                        width: size[0],
-                        height: size[1],
-                        depth_or_array_layers: 1,
-                    },
-                    mip_level_count: 1,
-                    sample_count: 1,
-                    dimension: wgpu::TextureDimension::D2,
-                    format: FORMAT,
-                    usage: wgpu::TextureUsages::RENDER_ATTACHMENT
-                        | wgpu::TextureUsages::TEXTURE_BINDING,
-                    view_formats: &[],
-                })
-                .create_view(&Default::default())
-        };
-        let outline = texture("Entity outline");
-        let swap = texture("Entity outline swap");
-        let group = |view: &wgpu::TextureView, sampler: &wgpu::Sampler| {
-            device.create_bind_group(&wgpu::BindGroupDescriptor {
-                label: Some("Entity outline pass"),
-                layout: &self.layout,
-                entries: &[
-                    wgpu::BindGroupEntry {
-                        binding: 0,
-                        resource: wgpu::BindingResource::TextureView(view),
-                    },
-                    wgpu::BindGroupEntry {
-                        binding: 1,
-                        resource: wgpu::BindingResource::Sampler(sampler),
-                    },
-                ],
-            })
-        };
-        let groups = [
-            group(&outline, &self.nearest),
-            group(&swap, &self.bilinear),
-            group(&outline, &self.bilinear),
-            group(&swap, &self.nearest),
-        ];
-        self.targets = Some(Targets {
-            size,
-            outline,
-            swap,
-            groups,
-        });
-    }
-
-    /// `LevelRenderer.executeOutline`, the post chain and `blitEntityOutline` onto `frame`.
-    pub(super) fn draw(
-        &self,
-        encoder: &mut wgpu::CommandEncoder,
-        frame: &wgpu::TextureView,
-        entity_group: &wgpu::BindGroup,
-        indices: &wgpu::Buffer,
-    ) {
-        let Some(t) = self.targets.as_ref().filter(|_| self.quads > 0) else {
-            return;
-        };
-        let clear = wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT);
-        {
-            let mut pass = begin(encoder, "Entity outline", &t.outline, clear);
-            pass.set_pipeline(&self.silhouette);
-            pass.set_bind_group(0, entity_group, &[]);
-            pass.set_index_buffer(indices.slice(..), wgpu::IndexFormat::Uint32);
-            pass.set_vertex_buffer(0, self.vertices.slice(..));
-            pass.draw_indexed(0..self.quads * 6, 0, 0..1);
-        }
-        // post_effect/entity_outline.json; its last pass only copies swap back to the
-        // outline target, so the blit reads swap.
-        let steps = [
-            ("Entity outline sobel", &t.swap, clear),
-            ("Entity outline blur across", &t.outline, clear),
-            ("Entity outline blur up", &t.swap, clear),
-            ("Entity outline blit", frame, wgpu::LoadOp::Load),
-        ];
-        for (i, (label, view, load)) in steps.into_iter().enumerate() {
-            let mut pass = begin(encoder, label, view, load);
-            pass.set_pipeline(&self.passes[i]);
-            pass.set_bind_group(0, &t.groups[i], &[]);
-            pass.draw(0..3, 0..1);
-        }
-    }
-}
-
-fn begin<'e>(
-    encoder: &'e mut wgpu::CommandEncoder,
-    label: &str,
-    view: &wgpu::TextureView,
-    load: wgpu::LoadOp<wgpu::Color>,
-) -> wgpu::RenderPass<'e> {
-    let attachments = [Some(wgpu::RenderPassColorAttachment {
-        view,
-        resolve_target: None,
-        depth_slice: None,
-        ops: wgpu::Operations {
-            load,
-            store: wgpu::StoreOp::Store,
-        },
-    })];
-    encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-        label: Some(label),
-        color_attachments: &attachments,
-        ..Default::default()
-    })
-}

crates/horizon-client-render/src/gfx/entity_outline.wgsl

@@ -1,60 +0,0 @@
-// The entity_outline post chain (post_effect/entity_outline.json) over the silhouettes of
-// the glowing entities, then RenderTarget.blitAndBlendToTexture onto the frame.
-@group(0) @binding(0) var source: texture_2d<f32>;
-@group(0) @binding(1) var source_sampler: sampler;
-
-struct PostOut {
-    @builtin(position) clip: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-};
-
-// screenquad.vsh, with v running down the rows as wgpu's textures do.
-@vertex fn vs_quad(@builtin(vertex_index) i: u32) -> PostOut {
-    let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
-    var out: PostOut;
-    out.clip = vec4(p * 2.0 - 1.0, 0.0, 1.0);
-    out.uv = vec2(p.x, 1.0 - p.y);
-    return out;
-}
-
-fn tap(uv: vec2<f32>) -> vec4<f32> {
-    return textureSampleLevel(source, source_sampler, uv, 0.0);
-}
-
-// entity_sobel.fsh: alpha marks where coverage changes, the colour is the mean of the
-// covered texels around.
-@fragment fn fs_sobel(in: PostOut) -> @location(0) vec4<f32> {
-    let texel = 1.0 / vec2<f32>(textureDimensions(source));
-    let center = tap(in.uv);
-    let left = tap(in.uv - vec2(texel.x, 0.0));
-    let right = tap(in.uv + vec2(texel.x, 0.0));
-    let up = tap(in.uv - vec2(0.0, texel.y));
-    let down = tap(in.uv + vec2(0.0, texel.y));
-    let total = clamp(abs(center.a - left.a) + abs(center.a - right.a)
-        + abs(center.a - up.a) + abs(center.a - down.a), 0.0, 1.0);
-    let color = center.rgb * center.a + left.rgb * left.a + right.rgb * right.a
-        + up.rgb * up.a + down.rgb * down.a;
-    return vec4(color * 0.2, total);
-}
-
-// entity_outline_box_blur.fsh at Radius 2: bilinear taps at -1.5 and 0.5 texels and half
-// a tap at 2; the colour averaged, the alpha summed.
-fn blur(uv: vec2<f32>, step: vec2<f32>) -> vec4<f32> {
-    let blurred = tap(uv + step * -1.5) + tap(uv + step * 0.5) + tap(uv + step * 2.0) / 2.0;
-    return vec4(blurred.rgb / 2.5, blurred.a);
-}
-
-// BlurDir (1, 0).
-@fragment fn fs_blur_x(in: PostOut) -> @location(0) vec4<f32> {
-    return blur(in.uv, vec2(1.0 / f32(textureDimensions(source).x), 0.0));
-}
-
-// BlurDir (0, 1): up the screen in GL's bottom-up textures, towards row 0 here.
-@fragment fn fs_blur_y(in: PostOut) -> @location(0) vec4<f32> {
-    return blur(in.uv, vec2(0.0, -1.0 / f32(textureDimensions(source).y)));
-}
-
-// blit_screen.fsh, blended by RenderPipelines.ENTITY_OUTLINE_BLIT.
-@fragment fn fs_blit(in: PostOut) -> @location(0) vec4<f32> {
-    return tap(in.uv);
-}

crates/horizon-client-render/src/gfx/hdr.rs

@@ -1,542 +0,0 @@
-//! HDR output (Horizon setting, off by default): the frame renders exactly as
-//! without it, into an 8-bit target in vanilla's gamma space, and one pass
-//! (`hdr.wgsl`) writes it to an HDR10 or scRGB swapchain at the player's paper
-//! white, expanding the world's highlights towards their peak brightness. The
-//! world is copied aside before the hand and HUD so only it is expanded.
-
-/// The swapchain HDR output presents to.
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub enum Output {
-    /// HDR10: 10-bit BT.2020 with the PQ curve, the display's own signal.
-    Pq,
-    /// scRGB: linear 16-bit float, BT.709 primaries, 1.0 = 80 nits.
-    ScRgb,
-}
-
-impl Output {
-    pub fn name(self) -> &'static str {
-        match self {
-            Self::Pq => "HDR10 (PQ)",
-            Self::ScRgb => "scRGB",
-        }
-    }
-    pub fn format(self) -> wgpu::TextureFormat {
-        match self {
-            Self::Pq => wgpu::TextureFormat::Rgb10a2Unorm,
-            Self::ScRgb => wgpu::TextureFormat::Rgba16Float,
-        }
-    }
-    pub fn color_space(self) -> wgpu::SurfaceColorSpace {
-        match self {
-            Self::Pq => wgpu::SurfaceColorSpace::Bt2100Pq,
-            Self::ScRgb => wgpu::SurfaceColorSpace::ExtendedSrgbLinear,
-        }
-    }
-    fn space(self) -> wgpu::SurfaceColorSpaces {
-        match self {
-            Self::Pq => wgpu::SurfaceColorSpaces::BT2100_PQ,
-            Self::ScRgb => wgpu::SurfaceColorSpaces::EXTENDED_SRGB_LINEAR,
-        }
-    }
-}
-
-/// The HDR output `caps` can present: HDR10 where offered, else scRGB.
-/// `HORIZON_HDR_OUTPUT=pq` or `scrgb` allows only that one.
-pub fn output(caps: &wgpu::SurfaceCapabilities) -> Option<Output> {
-    pick(caps, std::env::var("HORIZON_HDR_OUTPUT").ok().as_deref())
-}
-fn pick(caps: &wgpu::SurfaceCapabilities, only: Option<&str>) -> Option<Output> {
-    [(Output::Pq, "pq"), (Output::ScRgb, "scrgb")]
-        .into_iter()
-        .filter(|(_, name)| only.is_none_or(|o| o == *name))
-        .map(|(output, _)| output)
-        .find(|o| caps.color_spaces(o.format()).contains(o.space()))
-}
-
-struct Targets {
-    size: [u32; 2],
-    frame: wgpu::Texture,
-    world: wgpu::Texture,
-    group: wgpu::BindGroup,
-}
-
-/// How one tier of light sources (`mesher::hdr_tier`) shines: `share` of the headroom for
-/// its brightest pixels, lifted from brightness `start` (none) to `full` (all of it).
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Tier {
-    pub share: f32,
-    pub start: f32,
-    pub full: f32,
-}
-/// Low, incandescent, bright and very bright.
-pub const TIERS: [Tier; 4] = [
-    Tier {
-        share: 0.2,
-        start: 0.08,
-        full: 0.09,
-    },
-    Tier {
-        share: 0.5,
-        start: 0.14,
-        full: 0.38,
-    },
-    Tier {
-        share: 0.6,
-        start: 0.14,
-        full: 0.38,
-    },
-    Tier {
-        share: 1.0,
-        start: 0.14,
-        full: 0.38,
-    },
-];
-
-pub struct Hdr {
-    layout: wgpu::BindGroupLayout,
-    pipeline: wgpu::RenderPipeline,
-    /// Zeroes the frame's alpha once the world is kept (`keep_world`): what draws after,
-    /// the hand, HUD and menus, raises it, so HDR output knows where they cover the world.
-    clear_alpha: wgpu::RenderPipeline,
-    /// Scales the frame's alpha down to 1/255 where the hand drew (`mark_hand`), so HDR
-    /// output keeps the hand at the world's brightness.
-    hand_mark: wgpu::RenderPipeline,
-    params: wgpu::Buffer,
-    /// The same pass drawing HDR10 for a screenshot (`capture`), with its own parameters,
-    /// so it can differ from the swapchain's in one frame.
-    capture_pipeline: wgpu::RenderPipeline,
-    capture_params: wgpu::Buffer,
-    pub output: Output,
-    /// The frame's format: what every other pipeline draws in.
-    format: wgpu::TextureFormat,
-    targets: Option<Targets>,
-    /// `HORIZON_HDR_DEBUG=1`: grey what isn't expanded, tint what is magenta.
-    debug: bool,
-    /// Paper white and peak brightness, in nits.
-    pub paper_white: f32,
-    pub peak: f32,
-    /// The display's black level, in nits: shadows are lifted onto it (`hdr.wgsl`).
-    pub black: f32,
-    pub tiers: [Tier; 4],
-    /// The HUD and menus' brightness, as a share of paper white (0.25..=1).
-    pub ui: f32,
-}
-
-impl Hdr {
-    pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat, output: Output) -> Self {
-        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-            label: Some("Horizon HDR"),
-            source: wgpu::ShaderSource::Wgsl(include_str!("../hdr.wgsl").into()),
-        });
-        let texture = |binding| wgpu::BindGroupLayoutEntry {
-            binding,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Texture {
-                sample_type: wgpu::TextureSampleType::Float { filterable: false },
-                view_dimension: wgpu::TextureViewDimension::D2,
-                multisampled: false,
-            },
-            count: None,
-        };
-        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-            label: Some("Horizon HDR bindings"),
-            entries: &[
-                texture(0),
-                texture(1),
-                wgpu::BindGroupLayoutEntry {
-                    binding: 2,
-                    visibility: wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Buffer {
-                        ty: wgpu::BufferBindingType::Uniform,
-                        has_dynamic_offset: false,
-                        min_binding_size: None,
-                    },
-                    count: None,
-                },
-            ],
-        });
-        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-            label: Some("Horizon HDR"),
-            bind_group_layouts: &[Some(&layout)],
-            ..Default::default()
-        });
-        let pipeline_for = |format| {
-            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                label: Some("Horizon HDR"),
-                layout: Some(&pipeline_layout),
-                vertex: wgpu::VertexState {
-                    module: &shader,
-                    entry_point: Some("vs_hdr"),
-                    compilation_options: Default::default(),
-                    buffers: &[],
-                },
-                primitive: Default::default(),
-                depth_stencil: None,
-                multisample: Default::default(),
-                fragment: Some(wgpu::FragmentState {
-                    module: &shader,
-                    entry_point: Some("fs_hdr"),
-                    compilation_options: Default::default(),
-                    targets: &[Some(wgpu::ColorTargetState {
-                        format,
-                        blend: None,
-                        write_mask: wgpu::ColorWrites::ALL,
-                    })],
-                }),
-                multiview_mask: None,
-                cache: None,
-            })
-        };
-        let alpha_pass = |label, blend| {
-            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                label: Some(label),
-                layout: Some(&device.create_pipeline_layout(&Default::default())),
-                vertex: wgpu::VertexState {
-                    module: &shader,
-                    entry_point: Some("vs_hdr"),
-                    compilation_options: Default::default(),
-                    buffers: &[],
-                },
-                primitive: Default::default(),
-                depth_stencil: None,
-                multisample: Default::default(),
-                fragment: Some(wgpu::FragmentState {
-                    module: &shader,
-                    entry_point: Some("fs_clear_alpha"),
-                    compilation_options: Default::default(),
-                    targets: &[Some(wgpu::ColorTargetState {
-                        format,
-                        blend,
-                        write_mask: wgpu::ColorWrites::ALPHA,
-                    })],
-                }),
-                multiview_mask: None,
-                cache: None,
-            })
-        };
-        let clear_alpha = alpha_pass("Horizon HDR UI mask", None);
-        // Alpha times the blend constant (1/255): the hand's 1 becomes 1/255, the world's 0
-        // stays 0.
-        let scale_alpha = wgpu::BlendComponent {
-            src_factor: wgpu::BlendFactor::Zero,
-            dst_factor: wgpu::BlendFactor::Constant,
-            operation: wgpu::BlendOperation::Add,
-        };
-        let hand_mark = alpha_pass(
-            "Horizon HDR hand mark",
-            Some(wgpu::BlendState {
-                color: scale_alpha,
-                alpha: scale_alpha,
-            }),
-        );
-        let params = || {
-            device.create_buffer(&wgpu::BufferDescriptor {
-                label: Some("Horizon HDR parameters"),
-                size: 80,
-                usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-                mapped_at_creation: false,
-            })
-        };
-        Self {
-            layout,
-            pipeline: pipeline_for(output.format()),
-            clear_alpha,
-            hand_mark,
-            params: params(),
-            capture_pipeline: pipeline_for(Output::Pq.format()),
-            capture_params: params(),
-            output,
-            format,
-            targets: None,
-            debug: std::env::var_os("HORIZON_HDR_DEBUG").is_some_and(|v| v == "1"),
-            paper_white: 200.0,
-            peak: 1000.0,
-            black: 0.0,
-            tiers: TIERS,
-            ui: 1.0,
-        }
-    }
-
-    /// The 8-bit frame every pass draws into this frame, sized like the window.
-    pub fn frame(&mut self, device: &wgpu::Device, size: [u32; 2]) -> wgpu::Texture {
-        if self.targets.as_ref().is_none_or(|t| t.size != size) {
-            let texture = |label, usage| {
-                device.create_texture(&wgpu::TextureDescriptor {
-                    label: Some(label),
-                    size: wgpu::Extent3d {
-                        width: size[0].max(1),
-                        height: size[1].max(1),
-                        depth_or_array_layers: 1,
-                    },
-                    mip_level_count: 1,
-                    sample_count: 1,
-                    dimension: wgpu::TextureDimension::D2,
-                    format: self.format,
-                    usage: usage | wgpu::TextureUsages::TEXTURE_BINDING,
-                    view_formats: &[],
-                })
-            };
-            let frame = texture(
-                "Horizon HDR frame",
-                wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
-            );
-            let world = texture("Horizon HDR world", wgpu::TextureUsages::COPY_DST);
-            let view = |t: &wgpu::Texture| t.create_view(&Default::default());
-            let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-                label: Some("Horizon HDR bindings"),
-                layout: &self.layout,
-                entries: &[
-                    wgpu::BindGroupEntry {
-                        binding: 0,
-                        resource: wgpu::BindingResource::TextureView(&view(&frame)),
-                    },
-                    wgpu::BindGroupEntry {
-                        binding: 1,
-                        resource: wgpu::BindingResource::TextureView(&view(&world)),
-                    },
-                    wgpu::BindGroupEntry {
-                        binding: 2,
-                        resource: self.params.as_entire_binding(),
-                    },
-                ],
-            });
-            self.targets = Some(Targets {
-                size,
-                frame,
-                world,
-                group,
-            });
-        }
-        self.targets.as_ref().unwrap().frame.clone()
-    }
-
-    /// Keeps the world as drawn so far, before the hand and HUD cover it, then zeroes the
-    /// frame's alpha: the world's marks live on in the copy, and whatever draws from here
-    /// on raises the alpha where it covers the world.
-    pub fn keep_world(&self, encoder: &mut wgpu::CommandEncoder) {
-        let Some(t) = &self.targets else {
-            return;
-        };
-        encoder.copy_texture_to_texture(
-            t.frame.as_image_copy(),
-            t.world.as_image_copy(),
-            t.frame.size(),
-        );
-        let view = t.frame.create_view(&Default::default());
-        let attachments = [Some(wgpu::RenderPassColorAttachment {
-            view: &view,
-            resolve_target: None,
-            depth_slice: None,
-            ops: wgpu::Operations {
-                load: wgpu::LoadOp::Load,
-                store: wgpu::StoreOp::Store,
-            },
-        })];
-        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-            label: Some("Horizon HDR UI mask"),
-            color_attachments: &attachments,
-            ..Default::default()
-        });
-        pass.set_pipeline(&self.clear_alpha);
-        pass.draw(0..3, 0..1);
-    }
-
-    /// After the hand: its pixels' alpha goes down to 1/255, below anything the HUD and
-    /// menus leave, so HDR output tells the hand (the world's brightness, never lifted)
-    /// from the UI (UI Brightness).
-    pub fn mark_hand(&self, encoder: &mut wgpu::CommandEncoder) {
-        let Some(t) = &self.targets else {
-            return;
-        };
-        let view = t.frame.create_view(&Default::default());
-        let attachments = [Some(wgpu::RenderPassColorAttachment {
-            view: &view,
-            resolve_target: None,
-            depth_slice: None,
-            ops: wgpu::Operations {
-                load: wgpu::LoadOp::Load,
-                store: wgpu::StoreOp::Store,
-            },
-        })];
-        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-            label: Some("Horizon HDR hand mark"),
-            color_attachments: &attachments,
-            ..Default::default()
-        });
-        pass.set_pipeline(&self.hand_mark);
-        let a = 1.0 / 255.0;
-        pass.set_blend_constant(wgpu::Color {
-            r: a,
-            g: a,
-            b: a,
-            a,
-        });
-        pass.draw(0..3, 0..1);
-    }
-
-    /// Writes the finished frame to the swapchain image `target`.
-    pub fn present(
-        &self,
-        queue: &wgpu::Queue,
-        encoder: &mut wgpu::CommandEncoder,
-        target: &wgpu::Texture,
-        world: bool,
-    ) {
-        let Some(t) = &self.targets else {
-            return;
-        };
-        queue.write_buffer(
-            &self.params,
-            0,
-            bytemuck::cast_slice(&self.params(world, self.output == Output::Pq)),
-        );
-        Self::draw(encoder, &self.pipeline, &t.group, target);
-    }
-
-    /// The frame `present` writes, as HDR10 (BT.2020, PQ, 10 bits a channel) whatever
-    /// the swapchain is, in a texture of its own for a screenshot (`Rgb10a2Unorm`).
-    pub fn capture(
-        &self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        encoder: &mut wgpu::CommandEncoder,
-        world: bool,
-    ) -> Option<wgpu::Texture> {
-        let t = self.targets.as_ref()?;
-        let texture = device.create_texture(&wgpu::TextureDescriptor {
-            label: Some("Horizon HDR screenshot"),
-            size: t.frame.size(),
-            mip_level_count: 1,
-            sample_count: 1,
-            dimension: wgpu::TextureDimension::D2,
-            format: Output::Pq.format(),
-            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
-            view_formats: &[],
-        });
-        let view = |t: &wgpu::Texture| t.create_view(&Default::default());
-        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("Horizon HDR screenshot bindings"),
-            layout: &self.layout,
-            entries: &[
-                wgpu::BindGroupEntry {
-                    binding: 0,
-                    resource: wgpu::BindingResource::TextureView(&view(&t.frame)),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 1,
-                    resource: wgpu::BindingResource::TextureView(&view(&t.world)),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 2,
-                    resource: self.capture_params.as_entire_binding(),
-                },
-            ],
-        });
-        queue.write_buffer(
-            &self.capture_params,
-            0,
-            bytemuck::cast_slice(&self.params(world, true)),
-        );
-        Self::draw(encoder, &self.capture_pipeline, &group, &texture);
-        Some(texture)
-    }
-
-    /// hdr.wgsl's `Params`.
-    fn params(&self, world: bool, pq: bool) -> [f32; 20] {
-        let paper = self.paper_white.max(1.0);
-        let mut params = [0.0; 20];
-        params[..5].copy_from_slice(&[
-            paper / 80.0,
-            (self.peak / paper).max(1.0),
-            f32::from(u8::from(world)),
-            f32::from(u8::from(self.debug)),
-            f32::from(u8::from(pq)),
-        ]);
-        params[5] = self.black.clamp(0.0, paper);
-        params[6] = self.ui.clamp(0.25, 1.0);
-        for (i, t) in self.tiers.iter().enumerate() {
-            params[8 + i] = t.share;
-            params[12 + i] = t.start;
-            params[16 + i] = t.full;
-        }
-        params
-    }
-
-    fn draw(
-        encoder: &mut wgpu::CommandEncoder,
-        pipeline: &wgpu::RenderPipeline,
-        group: &wgpu::BindGroup,
-        target: &wgpu::Texture,
-    ) {
-        let view = target.create_view(&Default::default());
-        let attachments = [Some(wgpu::RenderPassColorAttachment {
-            view: &view,
-            resolve_target: None,
-            depth_slice: None,
-            ops: wgpu::Operations {
-                load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
-                store: wgpu::StoreOp::Store,
-            },
-        })];
-        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-            label: Some("Horizon HDR"),
-            color_attachments: &attachments,
-            ..Default::default()
-        });
-        pass.set_pipeline(pipeline);
-        pass.set_bind_group(0, group, &[]);
-        pass.draw(0..3, 0..1);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{Output, pick};
-    use wgpu::{SurfaceColorSpaces as S, TextureFormat as F};
-
-    #[test]
-    fn hdr_shaders_validate() {
-        let entity = crate::overlay::wgsl_constants() + include_str!("../entity.wgsl");
-        for source in [
-            include_str!("../hdr.wgsl"),
-            include_str!("../terrain.wgsl"),
-            &entity,
-        ] {
-            let module = naga::front::wgsl::parse_str(source).unwrap();
-            naga::valid::Validator::new(
-                naga::valid::ValidationFlags::all(),
-                naga::valid::Capabilities::all(),
-            )
-            .validate(&module)
-            .unwrap();
-        }
-    }
-
-    fn caps(offered: &[(F, S)]) -> wgpu::SurfaceCapabilities {
-        wgpu::SurfaceCapabilities {
-            format_capabilities: offered
-                .iter()
-                .map(|&(format, color_spaces)| wgpu::SurfaceFormatCapabilities {
-                    format,
-                    color_spaces,
-                })
-                .collect(),
-            ..Default::default()
-        }
-    }
-
-    #[test]
-    fn hdr10_first_then_scrgb() {
-        let both = caps(&[
-            (F::Bgra8UnormSrgb, S::SRGB),
-            (F::Rgb10a2Unorm, S::BT2100_PQ | S::BT2100_HLG),
-            (F::Rgba16Float, S::EXTENDED_SRGB_LINEAR),
-        ]);
-        assert_eq!(pick(&both, None), Some(Output::Pq));
-        assert_eq!(pick(&both, Some("scrgb")), Some(Output::ScRgb));
-        let scrgb = caps(&[(F::Rgba16Float, S::EXTENDED_SRGB_LINEAR)]);
-        assert_eq!(pick(&scrgb, None), Some(Output::ScRgb));
-        assert_eq!(pick(&scrgb, Some("pq")), None);
-        assert_eq!(pick(&caps(&[(F::Bgra8UnormSrgb, S::SRGB)]), None), None);
-    }
-}

crates/horizon-client-render/src/gfx/readback.rs

@@ -1,213 +0,0 @@
-//! Screenshots of a swapchain that cannot be copied from. OpenGL's surfaces
-//! offer `RENDER_ATTACHMENT` only, so a frame whose pixels are read back
-//! (the screenshot key, a world's icon) is drawn into a texture that can be,
-//! then drawn onto the swapchain image as a fullscreen triangle.
-
-/// The texture a frame to read back is drawn into, and the pass that puts it
-/// on the swapchain afterwards.
-#[derive(Default)]
-pub struct Readback {
-    texture: Option<wgpu::Texture>,
-    blitter: Option<(wgpu::TextureFormat, wgpu::util::TextureBlitter)>,
-    /// A frame drew into `texture` and still has to reach the swapchain.
-    drawn: bool,
-}
-
-impl Readback {
-    /// The texture this frame draws into instead of the swapchain image
-    /// `surface`: `None` unless the frame is read back (`screenshot`) and the
-    /// image cannot be copied from.
-    pub fn target(
-        &mut self,
-        device: &wgpu::Device,
-        surface: &wgpu::Texture,
-        screenshot: bool,
-    ) -> Option<wgpu::Texture> {
-        if !screenshot || surface.usage().contains(wgpu::TextureUsages::COPY_SRC) {
-            return None;
-        }
-        let format = surface.format().remove_srgb_suffix();
-        if self
-            .texture
-            .as_ref()
-            .is_none_or(|t| t.size() != surface.size() || t.format() != format)
-        {
-            self.texture = Some(device.create_texture(&wgpu::TextureDescriptor {
-                label: Some("Horizon screenshot frame"),
-                size: surface.size(),
-                mip_level_count: 1,
-                sample_count: 1,
-                dimension: wgpu::TextureDimension::D2,
-                format,
-                usage: wgpu::TextureUsages::RENDER_ATTACHMENT
-                    | wgpu::TextureUsages::COPY_SRC
-                    | wgpu::TextureUsages::TEXTURE_BINDING,
-                view_formats: &[],
-            }));
-        }
-        self.drawn = true;
-        self.texture.clone()
-    }
-
-    /// Draws the frame `target` gave onto the swapchain image `surface`; nothing
-    /// when this frame drew straight into it.
-    pub fn present(
-        &mut self,
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        surface: &wgpu::Texture,
-    ) {
-        if !std::mem::take(&mut self.drawn) {
-            return;
-        }
-        let Some(texture) = &self.texture else {
-            return;
-        };
-        // The frame's passes write the swapchain through its non-sRGB view
-        // (`view_formats`), so the copy goes there unconverted too.
-        let format = surface.format().remove_srgb_suffix();
-        if self.blitter.as_ref().is_none_or(|b| b.0 != format) {
-            self.blitter = Some((format, wgpu::util::TextureBlitter::new(device, format)));
-        }
-        let target = surface.create_view(&wgpu::TextureViewDescriptor {
-            format: Some(format),
-            ..Default::default()
-        });
-        let source = texture.create_view(&Default::default());
-        if let Some((_, blitter)) = &self.blitter {
-            blitter.copy(device, encoder, &source, &target);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn device() -> Option<(wgpu::Device, wgpu::Queue)> {
-        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
-        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
-        pollster::block_on(adapter.request_device(&Default::default())).ok()
-    }
-
-    fn texture(device: &wgpu::Device, usage: wgpu::TextureUsages) -> wgpu::Texture {
-        device.create_texture(&wgpu::TextureDescriptor {
-            label: None,
-            size: wgpu::Extent3d {
-                width: 70,
-                height: 3,
-                depth_or_array_layers: 1,
-            },
-            mip_level_count: 1,
-            sample_count: 1,
-            dimension: wgpu::TextureDimension::D2,
-            format: wgpu::TextureFormat::Bgra8Unorm,
-            usage,
-            view_formats: &[],
-        })
-    }
-
-    fn clear(encoder: &mut wgpu::CommandEncoder, texture: &wgpu::Texture, color: wgpu::Color) {
-        let view = texture.create_view(&Default::default());
-        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-            label: None,
-            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                view: &view,
-                resolve_target: None,
-                depth_slice: None,
-                ops: wgpu::Operations {
-                    load: wgpu::LoadOp::Clear(color),
-                    store: wgpu::StoreOp::Store,
-                },
-            })],
-            ..Default::default()
-        });
-    }
-
-    fn read(device: &wgpu::Device, buffer: &wgpu::Buffer) -> Vec<u8> {
-        buffer.map_async(wgpu::MapMode::Read, .., |r| r.unwrap());
-        device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
-        buffer.get_mapped_range(..).unwrap().to_vec()
-    }
-
-    /// The last pixel of the last row of a 70x3 frame read back by `copy_frame`.
-    fn last_pixel(device: &wgpu::Device, buffer: &wgpu::Buffer) -> Vec<u8> {
-        let pixels = read(device, buffer);
-        let row = 70usize * 4;
-        let last = row.next_multiple_of(256) * 2 + row - 4;
-        pixels[last..last + 4].to_vec()
-    }
-
-    /// The renderer's screenshot path on a surface like OpenGL's (#3510): the
-    /// frame is drawn into `target`, read back with `copy_frame` and drawn on
-    /// the swapchain, with no validation error (the copy used to need the
-    /// swapchain's missing `COPY_SRC`), and the swapchain shows the frame.
-    #[test]
-    fn screenshot_of_a_surface_without_copy_src() {
-        let Some((device, queue)) = device() else {
-            return;
-        };
-        // Sampled only so the test can look at what reached it.
-        let surface = texture(
-            &device,
-            wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
-        );
-        let check = texture(
-            &device,
-            wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
-        );
-        let blitter = wgpu::util::TextureBlitter::new(&device, wgpu::TextureFormat::Bgra8Unorm);
-        let mut readback = Readback::default();
-        let colors = [
-            (1.0, [0, 0, 255, 255]),
-            // A second screenshot reuses the texture.
-            (0.0, [255, 0, 0, 255]),
-        ];
-        for (r, bgra) in colors {
-            let color = wgpu::Color {
-                r,
-                g: 0.0,
-                b: 1.0 - r,
-                a: 1.0,
-            };
-            let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
-            let mut encoder = device.create_command_encoder(&Default::default());
-            let frame = readback
-                .target(&device, &surface, true)
-                .unwrap_or_else(|| surface.clone());
-            clear(&mut encoder, &frame, color);
-            let buffer = crate::gfx::copy_frame(&device, &mut encoder, &frame, [70, 3]);
-            readback.present(&device, &mut encoder, &surface);
-            queue.submit([encoder.finish()]);
-            if let Some(error) = pollster::block_on(scope.pop()) {
-                panic!("{error}");
-            }
-            assert_eq!(last_pixel(&device, &buffer), bgra);
-            let mut encoder = device.create_command_encoder(&Default::default());
-            let view = |t: &wgpu::Texture| t.create_view(&Default::default());
-            blitter.copy(&device, &mut encoder, &view(&surface), &view(&check));
-            let buffer = crate::gfx::copy_frame(&device, &mut encoder, &check, [70, 3]);
-            queue.submit([encoder.finish()]);
-            assert_eq!(last_pixel(&device, &buffer), bgra);
-        }
-        assert!(!readback.drawn);
-    }
-
-    /// A surface that can be copied from, or a frame nobody reads back,
-    /// draws straight into the swapchain image.
-    #[test]
-    fn frames_draw_straight_to_a_readable_surface() {
-        let Some((device, _)) = device() else {
-            return;
-        };
-        let mut readback = Readback::default();
-        let readable = texture(
-            &device,
-            wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
-        );
-        assert!(readback.target(&device, &readable, true).is_none());
-        let surface = texture(&device, wgpu::TextureUsages::RENDER_ATTACHMENT);
-        assert!(readback.target(&device, &surface, false).is_none());
-        assert!(readback.texture.is_none() && !readback.drawn);
-    }
-}

crates/horizon-client-render/src/gfx/sunrise_fan.rs

@@ -1,131 +0,0 @@
-//! The sunrise/sunset fan (`SkyRenderer.renderSunriseAndSunset`) as the sky
-//! shader tests it. The fan's 16 triangles depend only on the sunrise alpha
-//! and the horizon the sun is on, so their vertices are built here once a
-//! frame instead of in every sky pixel (#3143: with the per-pixel build, four
-//! `sin`/`cos` per triangle, the sky pass took 10.2 ms at dawn at 1080p on an
-//! Intel UHD 730 against 0.6 ms by day; now 1.8 ms).
-//!
-//! Möller-Trumbore from the camera reduces to triple products: with apex A
-//! and rim vertices r0, r1, a ray d hits at barycentrics proportional to
-//! (`[d, r0, r1]`, `[A, d, r1]`, `[A, r0, d]`), each a dot of d with a
-//! constant normal, and their sum S is the negated determinant. A hit needs
-//! S on the side of `[A, r0, r1]`, so only the triangles whose rim normals'
-//! dots change sign there are tested in full.
-use glam::Vec3;
-
-pub const TRIANGLES: usize = 16;
-
-/// Per triangle: xyz `r0 × r1` (its dot with a ray is the apex's weight
-/// times S), w `[A, r0, r1]` (its sign is S's where the hit lies ahead).
-/// Then per rim vertex: xyz `r × A`.
-pub fn normals(alpha: f32, sun: Vec3) -> [[f32; 4]; 2 * TRIANGLES] {
-    let (apex, rim) = vertices(alpha, sun);
-    let mut out = [[0.0; 4]; 2 * TRIANGLES];
-    for i in 0..TRIANGLES {
-        let (r0, r1) = (rim[i], rim[(i + 1) % TRIANGLES]);
-        out[i] = r0.cross(r1).extend(apex.dot(r0.cross(r1))).to_array();
-        out[TRIANGLES + i] = r0.cross(apex).extend(0.0).to_array();
-    }
-    out
-}
-
-/// The fan's apex and rim in camera space, as vanilla builds them: the
-/// fan turned to the horizon the sun sets on (or rises from), its rim
-/// tilted by the alpha.
-fn vertices(alpha: f32, sun: Vec3) -> (Vec3, [Vec3; TRIANGLES]) {
-    // sin(sunAngle) < 0 flips the fan to the other horizon; sun.z = -sin(sunAngle).
-    let flip = if -sun.z < 0.0 { 180f32 } else { 0.0 };
-    let (s, c) = (flip + 90.0).to_radians().sin_cos();
-    let rotate_x90 = |v: Vec3| Vec3::new(v.x, -v.z, v.y);
-    let apex = rotate_x90(Vec3::new(-100.0 * s, 100.0 * c, 0.0));
-    let rim = std::array::from_fn(|i| {
-        let a = i as f32 * std::f32::consts::TAU / TRIANGLES as f32;
-        let l = Vec3::new(a.sin() * 120.0, a.cos() * 120.0, -a.cos() * 40.0 * alpha);
-        rotate_x90(Vec3::new(l.x * c - l.y * s, l.x * s + l.y * c, l.z))
-    });
-    (apex, rim)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// terrain.wgsl's `sunrise_weight` over the normals.
-    fn weight(normals: &[[f32; 4]; 2 * TRIANGLES], d: Vec3) -> f32 {
-        let n = |i: usize| Vec3::from_slice(&normals[i][..3]);
-        let mut best = 0.0f32;
-        let mut k0 = d.dot(n(TRIANGLES));
-        for i in 0..TRIANGLES {
-            let k1 = d.dot(n(TRIANGLES + (i + 1) % TRIANGLES));
-            let w = normals[i][3];
-            if k0 * w <= 0.0 && k1 * w >= 0.0 {
-                let apex = d.dot(n(i));
-                let s = apex + k1 - k0;
-                if s.abs() >= 1e-6
-                    && s * w > 0.0
-                    && apex * s >= 0.0
-                    && k1 * s >= 0.0
-                    && k0 * s <= 0.0
-                {
-                    best = best.max(apex / s);
-                }
-            }
-            k0 = k1;
-        }
-        best
-    }
-
-    /// The shader's former per-pixel Möller-Trumbore over the same vertices.
-    fn reference(alpha: f32, sun: Vec3, d: Vec3) -> f32 {
-        let (apex, rim) = vertices(alpha, sun);
-        let mut best = 0.0f32;
-        for i in 0..TRIANGLES {
-            let e1 = rim[i] - apex;
-            let e2 = rim[(i + 1) % TRIANGLES] - apex;
-            let pv = d.cross(e2);
-            let det = e1.dot(pv);
-            if det.abs() < 1e-6 {
-                continue;
-            }
-            let tv = -apex;
-            let u = tv.dot(pv) / det;
-            let qv = tv.cross(e1);
-            let v = d.dot(qv) / det;
-            let t = e2.dot(qv) / det;
-            if u >= 0.0 && v >= 0.0 && u + v <= 1.0 && t > 0.0 {
-                best = best.max(1.0 - u - v);
-            }
-        }
-        best
-    }
-
-    #[test]
-    fn normals_weigh_every_ray_as_the_per_pixel_fan_did() {
-        let mut hits = 0;
-        for (alpha, sun_z) in [(1.0f32, -0.2f32), (0.6, 0.3), (0.05, -0.9), (0.9, 0.05)] {
-            let sun = Vec3::new(0.0, (1.0 - sun_z * sun_z).sqrt(), sun_z);
-            let normals = normals(alpha, sun);
-            for yaw in 0..180 {
-                for pitch in -45..=45 {
-                    let (yaw, pitch) = (
-                        (yaw as f32 * 2.0).to_radians(),
-                        (pitch as f32 * 2.0).to_radians(),
-                    );
-                    let d = Vec3::new(
-                        yaw.cos() * pitch.cos(),
-                        pitch.sin(),
-                        yaw.sin() * pitch.cos(),
-                    );
-                    let (got, want) = (weight(&normals, d), reference(alpha, sun, d));
-                    assert!(
-                        (got - want).abs() < 1e-4,
-                        "{alpha} {sun_z} {d}: {got} vs {want}"
-                    );
-                    hits += usize::from(want > 0.0);
-                }
-            }
-        }
-        // The fan covers part of the sky, not none of it.
-        assert!(hits > 1000, "{hits}");
-    }
-}

crates/horizon-client-render/src/gfx/view.rs

@@ -1,133 +0,0 @@
-//! The views a frame is drawn from. A flat screen has one; a headset has
-//! one per eye. Every view shares the frame's camera position, so the
-//! camera-relative world (section origins, entity offsets) is built once and
-//! only each view's rotation and lens differ.
-
-use glam::Mat4;
-
-/// The most views one frame draws.
-const MAX_VIEWS: usize = 2;
-
-/// One eye's view of the camera-relative world.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct View {
-    /// Camera-relative world to eye: a rotation, plus the eye's offset from
-    /// the camera on a headset.
-    pub view: Mat4,
-    /// Reversed-Z perspective: the near plane at depth 1, far at 0.
-    pub projection: Mat4,
-    /// Width over height of the image this view fills.
-    pub aspect: f32,
-    /// `tan(fov_y / 2)`, for shaders rebuilding view rays from NDC.
-    pub tan_half_fov: f32,
-}
-
-impl View {
-    /// The flat-screen view: vanilla's camera rotation and a symmetric
-    /// vertical field of view.
-    pub fn screen(yaw: f32, pitch: f32, fov_degrees: f32, aspect: f32, far: f32) -> Self {
-        Self {
-            view: crate::camera::view_matrix(yaw, pitch),
-            projection: super::world_projection(fov_degrees, aspect, far),
-            aspect,
-            tan_half_fov: (fov_degrees.to_radians() / 2.0).tan(),
-        }
-    }
-
-    /// Clip space from the camera-relative world, with `pose` (view bobbing,
-    /// nausea spin) between the lens and the rotation.
-    pub fn view_proj(&self, pose: Mat4) -> Mat4 {
-        self.projection * pose * self.view
-    }
-}
-
-/// Every view of a frame, and the one geometry is culled with.
-#[derive(Clone, Copy, Debug)]
-pub struct ViewSet {
-    views: [View; MAX_VIEWS],
-    len: usize,
-    cull: View,
-}
-
-impl ViewSet {
-    /// A frame drawn from `view` alone, culled with it.
-    pub fn single(view: View) -> Self {
-        Self {
-            views: [view; MAX_VIEWS],
-            len: 1,
-            cull: view,
-        }
-    }
-
-    /// The view the HUD, hand and screen-space effects follow.
-    pub fn primary(&self) -> &View {
-        &self.views[0]
-    }
-
-    pub fn views(&self) -> &[View] {
-        &self.views[..self.len]
-    }
-
-    /// The view whose frustum covers every other view's.
-    pub fn cull(&self) -> &View {
-        &self.cull
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// The formulas `Renderer` used before views existed, kept to pin the
-    /// screen view to them bit for bit.
-    fn legacy_view_proj(fov: f32, yaw: f32, pitch: f32, pose: Mat4, aspect: f32, far: f32) -> Mat4 {
-        super::super::world_projection(fov, aspect, far)
-            * pose
-            * crate::camera::view_matrix(yaw, pitch)
-    }
-
-    fn poses() -> [Mat4; 3] {
-        [
-            Mat4::IDENTITY,
-            Mat4::from_translation(glam::Vec3::new(0.013, -0.027, 0.0))
-                * Mat4::from_rotation_z(0.021),
-            Mat4::from_rotation_y(0.4) * Mat4::from_scale(glam::Vec3::new(1.1, 0.9, 1.0)),
-        ]
-    }
-
-    #[test]
-    fn the_screen_view_matches_the_legacy_projection_bit_for_bit() {
-        for (fov, yaw, pitch, aspect, far) in [
-            (70.0, 0.0, 0.0, 16.0 / 9.0, 512.0),
-            (110.0, -137.25, 61.5, 21.0 / 9.0, 8192.0),
-            (30.0, 359.9, -90.0, 4.0 / 3.0, 96.0),
-            (82.333, 12.5, 7.75, 1.0, 1024.0),
-        ] {
-            let view = View::screen(yaw, pitch, fov, aspect, far);
-            for pose in poses() {
-                let old = legacy_view_proj(fov, yaw, pitch, pose, aspect, far);
-                let new = view.view_proj(pose);
-                assert_eq!(
-                    old.to_cols_array().map(f32::to_bits),
-                    new.to_cols_array().map(f32::to_bits),
-                    "fov {fov} yaw {yaw} pitch {pitch}"
-                );
-            }
-            assert_eq!(view.view, crate::camera::view_matrix(yaw, pitch));
-            assert_eq!(
-                view.tan_half_fov.to_bits(),
-                (fov.to_radians() / 2.0).tan().to_bits()
-            );
-            assert_eq!(view.aspect.to_bits(), aspect.to_bits());
-        }
-    }
-
-    #[test]
-    fn a_single_view_set_draws_and_culls_with_its_view() {
-        let view = View::screen(45.0, 10.0, 70.0, 16.0 / 9.0, 512.0);
-        let set = ViewSet::single(view);
-        assert_eq!(set.views(), &[view]);
-        assert_eq!(*set.primary(), view);
-        assert_eq!(*set.cull(), view);
-    }
-}

crates/horizon-client-render/src/gfx/world_post.rs

@@ -1,564 +0,0 @@
-//! Resolution scale, FXAA and TAA (Horizon settings): the world renders into its
-//! own target at the scaled size, then one full-screen pass copies or
-//! anti-aliases it onto the screen, under the hand and HUD. With none on,
-//! the world renders straight to the screen.
-//!
-//! TAA jitters the world's projection by a sub-pixel offset each frame and blends
-//! the frame into a history reprojected through the depth buffer: its motion
-//! vectors are the camera's, so what moves on its own leans on the neighbourhood
-//! clamp alone.
-
-use glam::{DMat4, DVec3, Mat4, Vec2};
-
-/// The TAA history format: 8 bits would band as frames accumulate.
-const HISTORY_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
-
-struct WorldTarget {
-    size: [u32; 2],
-    color: wgpu::TextureView,
-    depth: wgpu::TextureView,
-    group: wgpu::BindGroup,
-    taa: Option<History>,
-}
-
-/// TAA's two history textures at the output size (the world's, times the upscale), written
-/// in turn: `resolve[i]` writes `history[i]` from the world and `history[1 - i]`; `show[i]`
-/// copies `history[i]` to the screen.
-struct History {
-    size: [u32; 2],
-    history: [wgpu::TextureView; 2],
-    resolve: [wgpu::BindGroup; 2],
-    show: [wgpu::BindGroup; 2],
-}
-
-/// `world_post.wgsl`'s `Taa`.
-#[repr(C)]
-#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
-struct TaaUniform {
-    /// This frame's unjittered clip space to the previous frame's.
-    reproject: [[f32; 4]; 4],
-    /// xy: this frame's jitter in clip space; z: 1 when the history is unusable.
-    jitter: [f32; 4],
-}
-
-/// TAA's GPU resources, absent when the device cannot compile the shader
-/// (the OpenGL backend's naga GLSL emitter does not support `textureLoad`
-/// from depth textures).
-struct TaaResources {
-    layout: wgpu::BindGroupLayout,
-    pipeline: wgpu::RenderPipeline,
-    uniform: wgpu::Buffer,
-}
-
-pub struct Post {
-    layout: wgpu::BindGroupLayout,
-    sampler: wgpu::Sampler,
-    copy: wgpu::RenderPipeline,
-    fxaa: wgpu::RenderPipeline,
-    format: wgpu::TextureFormat,
-    /// World resolution relative to the window (0.5..=2.0).
-    pub scale: f32,
-    pub antialias: bool,
-    pub taa: bool,
-    /// Output pixels per rendered pixel while TAA is on (1: native): the world renders
-    /// this much smaller and TAA rebuilds it at the resolution scale's size.
-    pub upscale: f32,
-    /// TAA runs this frame (`jitter`): not on the title screen or under a shader pack.
-    taa_on: bool,
-    target: Option<WorldTarget>,
-    taa_resources: Option<TaaResources>,
-    /// Frames jittered so far (the Halton index), and which history the next resolve writes.
-    taa_frame: u32,
-    /// The last TAA frame's unjittered `view_proj` and camera, `None` once a frame ran without it.
-    taa_previous: Option<(DMat4, DVec3)>,
-    taa_this_frame: TaaUniform,
-}
-
-impl Post {
-    pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
-        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-            label: Some("Horizon post"),
-            source: wgpu::ShaderSource::Wgsl(include_str!("../world_post.wgsl").into()),
-        });
-        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-            label: Some("Horizon post bindings"),
-            entries: &[
-                wgpu::BindGroupLayoutEntry {
-                    binding: 0,
-                    visibility: wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Texture {
-                        sample_type: wgpu::TextureSampleType::Float { filterable: true },
-                        view_dimension: wgpu::TextureViewDimension::D2,
-                        multisampled: false,
-                    },
-                    count: None,
-                },
-                wgpu::BindGroupLayoutEntry {
-                    binding: 1,
-                    visibility: wgpu::ShaderStages::FRAGMENT,
-                    ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
-                    count: None,
-                },
-            ],
-        });
-        let texture = |binding, sample_type| wgpu::BindGroupLayoutEntry {
-            binding,
-            visibility: wgpu::ShaderStages::FRAGMENT,
-            ty: wgpu::BindingType::Texture {
-                sample_type,
-                view_dimension: wgpu::TextureViewDimension::D2,
-                multisampled: false,
-            },
-            count: None,
-        };
-        let float = wgpu::TextureSampleType::Float { filterable: true };
-        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-            label: Some("Horizon post"),
-            bind_group_layouts: &[Some(&layout)],
-            ..Default::default()
-        });
-        let pipeline = |entry: &str, layout: &wgpu::PipelineLayout, format| {
-            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                label: Some("Horizon post"),
-                layout: Some(layout),
-                vertex: wgpu::VertexState {
-                    module: &shader,
-                    entry_point: Some("vs_post"),
-                    compilation_options: Default::default(),
-                    buffers: &[],
-                },
-                primitive: Default::default(),
-                depth_stencil: None,
-                multisample: Default::default(),
-                fragment: Some(wgpu::FragmentState {
-                    module: &shader,
-                    entry_point: Some(entry),
-                    compilation_options: Default::default(),
-                    targets: &[Some(wgpu::ColorTargetState {
-                        format,
-                        blend: None,
-                        write_mask: wgpu::ColorWrites::ALL,
-                    })],
-                }),
-                multiview_mask: None,
-                cache: None,
-            })
-        };
-        // The OpenGL backend's GLSL translator does not support textureLoad
-        // from depth textures: on devices running through OpenGL (such as older
-        // Intel GPUs on Linux), TAA cannot compile its pipeline.
-        let taa_resources = {
-            let taa_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-                label: Some("Horizon TAA bindings"),
-                entries: &[
-                    texture(0, float),
-                    wgpu::BindGroupLayoutEntry {
-                        binding: 1,
-                        visibility: wgpu::ShaderStages::FRAGMENT,
-                        ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
-                        count: None,
-                    },
-                    texture(2, float),
-                    texture(3, wgpu::TextureSampleType::Depth),
-                    wgpu::BindGroupLayoutEntry {
-                        binding: 4,
-                        visibility: wgpu::ShaderStages::FRAGMENT,
-                        ty: wgpu::BindingType::Buffer {
-                            ty: wgpu::BufferBindingType::Uniform,
-                            has_dynamic_offset: false,
-                            min_binding_size: None,
-                        },
-                        count: None,
-                    },
-                ],
-            });
-            let taa_pipeline_layout =
-                device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-                    label: Some("Horizon TAA"),
-                    bind_group_layouts: &[Some(&taa_layout)],
-                    ..Default::default()
-                });
-            let validation = device.push_error_scope(wgpu::ErrorFilter::Validation);
-            let internal = device.push_error_scope(wgpu::ErrorFilter::Internal);
-            let taa_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-                label: Some("Horizon TAA"),
-                layout: Some(&taa_pipeline_layout),
-                vertex: wgpu::VertexState {
-                    module: &shader,
-                    entry_point: Some("vs_post"),
-                    compilation_options: Default::default(),
-                    buffers: &[],
-                },
-                primitive: Default::default(),
-                depth_stencil: None,
-                multisample: Default::default(),
-                fragment: Some(wgpu::FragmentState {
-                    module: &shader,
-                    entry_point: Some("fs_taa"),
-                    compilation_options: Default::default(),
-                    targets: &[Some(wgpu::ColorTargetState {
-                        format: HISTORY_FORMAT,
-                        blend: None,
-                        write_mask: wgpu::ColorWrites::ALL,
-                    })],
-                }),
-                multiview_mask: None,
-                cache: None,
-            });
-            let internal = pollster::block_on(internal.pop());
-            match internal.or(pollster::block_on(validation.pop())) {
-                None => {
-                    let uniform = device.create_buffer(&wgpu::BufferDescriptor {
-                        label: Some("Horizon TAA"),
-                        size: std::mem::size_of::<TaaUniform>() as u64,
-                        usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-                        mapped_at_creation: false,
-                    });
-                    Some(TaaResources {
-                        layout: taa_layout,
-                        pipeline: taa_pipeline,
-                        uniform,
-                    })
-                }
-                Some(e) => {
-                    log::warn!("Horizon renderer: temporal anti-aliasing unavailable ({e})");
-                    None
-                }
-            }
-        };
-        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
-            label: Some("Horizon post"),
-            mag_filter: wgpu::FilterMode::Linear,
-            min_filter: wgpu::FilterMode::Linear,
-            ..Default::default()
-        });
-        Self {
-            copy: pipeline("fs_copy", &pipeline_layout, format),
-            fxaa: pipeline("fs_fxaa", &pipeline_layout, format),
-            layout,
-            sampler,
-            format,
-            scale: 1.0,
-            antialias: false,
-            taa: false,
-            upscale: 1.0,
-            taa_on: false,
-            target: None,
-            taa_resources,
-            taa_frame: 0,
-            taa_previous: None,
-            taa_this_frame: bytemuck::Zeroable::zeroed(),
-        }
-    }
-
-    /// Whether TAA is supported on this GPU/backend.
-    pub fn supports_taa(&self) -> bool {
-        self.taa_resources.is_some()
-    }
-
-    /// The world's rendered size and the size it is shown at (TAA's history).
-    fn sizes(&self, window: [u32; 2]) -> ([u32; 2], [u32; 2]) {
-        let output = window.map(|v| ((v as f32 * self.scale).round() as u32).clamp(1, 8192));
-        let upscale = if self.taa_on { self.upscale } else { 1.0 };
-        (
-            output.map(|v| ((v as f32 / upscale).round() as u32).max(1)),
-            output,
-        )
-    }
-
-    /// TAA's sub-pixel jitter this frame, as a clip-space matrix to multiply into the
-    /// world's projection (identity while `on` is false); `view_proj` is the unjittered
-    /// projection, relative to `camera`. Call it before `prepare`, once per frame.
-    pub fn jitter(&mut self, window: [u32; 2], on: bool, view_proj: Mat4, camera: DVec3) -> Mat4 {
-        self.taa_on = on && self.taa && self.taa_resources.is_some();
-        if !self.taa_on {
-            self.taa_previous = None;
-            return Mat4::IDENTITY;
-        }
-        self.taa_frame = self.taa_frame.wrapping_add(1);
-        let (size, _) = self.sizes(window);
-        // Halton (2, 3) over 8 frames per output pixel (FSR's count), in rendered
-        // pixels around the centre.
-        let phases = (8.0 * self.upscale * self.upscale).ceil() as u32;
-        let i = self.taa_frame % phases + 1;
-        let offset = Vec2::new(halton(i, 2), halton(i, 3)) - 0.5;
-        let jitter = offset * 2.0 / Vec2::new(size[0] as f32, size[1] as f32);
-        let current = view_proj.as_dmat4();
-        let (reproject, reset) = match self.taa_previous {
-            Some((previous, previous_camera)) => (
-                reprojection(previous, previous_camera, current, camera),
-                0.0,
-            ),
-            None => (DMat4::IDENTITY, 1.0),
-        };
-        self.taa_previous = Some((current, camera));
-        self.taa_this_frame = TaaUniform {
-            reproject: reproject.as_mat4().to_cols_array_2d(),
-            jitter: [jitter.x, jitter.y, reset, 0.0],
-        };
-        Mat4::from_translation(jitter.extend(0.0))
-    }
-
-    /// The world's colour and depth targets this frame, or `None` to draw
-    /// it straight to the screen.
-    /// `always`: a target even at scale 1 without anti-aliasing (a shader pack reads it).
-    pub fn prepare(
-        &mut self,
-        device: &wgpu::Device,
-        window: [u32; 2],
-        always: bool,
-    ) -> Option<(wgpu::TextureView, wgpu::TextureView)> {
-        if self.scale == 1.0 && !self.antialias && !self.taa_on && !always {
-            self.target = None;
-            return None;
-        }
-        let (size, output) = self.sizes(window);
-        let history_size = self.taa_on.then_some(output);
-        if self
-            .target
-            .as_ref()
-            .is_none_or(|t| t.size != size || t.taa.as_ref().map(|h| h.size) != history_size)
-        {
-            let make_tex = |label, size: [u32; 2], format, usage| {
-                device.create_texture(&wgpu::TextureDescriptor {
-                    label: Some(label),
-                    size: wgpu::Extent3d {
-                        width: size[0],
-                        height: size[1],
-                        depth_or_array_layers: 1,
-                    },
-                    mip_level_count: 1,
-                    sample_count: 1,
-                    dimension: wgpu::TextureDimension::D2,
-                    format,
-                    usage,
-                    view_formats: &[],
-                })
-            };
-            let sampled =
-                wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;
-            let color = make_tex("Scaled world", size, self.format, sampled)
-                .create_view(&Default::default());
-            // TEXTURE_BINDING: occlusion culling and TAA read it.
-            let depth = make_tex(
-                "Scaled world depth",
-                size,
-                wgpu::TextureFormat::Depth32Float,
-                sampled,
-            )
-            .create_view(&Default::default());
-            let group = self.bind(device, &color);
-            let taa = history_size.and_then(|output| {
-                let res = self.taa_resources.as_ref()?;
-                let history = [0, 1].map(|_| {
-                    make_tex("TAA history", output, HISTORY_FORMAT, sampled)
-                        .create_view(&Default::default())
-                });
-                let resolve = [0, 1].map(|i| {
-                    device.create_bind_group(&wgpu::BindGroupDescriptor {
-                        label: Some("Horizon TAA"),
-                        layout: &res.layout,
-                        entries: &[
-                            wgpu::BindGroupEntry {
-                                binding: 0,
-                                resource: wgpu::BindingResource::TextureView(&color),
-                            },
-                            wgpu::BindGroupEntry {
-                                binding: 1,
-                                resource: wgpu::BindingResource::Sampler(&self.sampler),
-                            },
-                            wgpu::BindGroupEntry {
-                                binding: 2,
-                                resource: wgpu::BindingResource::TextureView(&history[1 - i]),
-                            },
-                            wgpu::BindGroupEntry {
-                                binding: 3,
-                                resource: wgpu::BindingResource::TextureView(&depth),
-                            },
-                            wgpu::BindGroupEntry {
-                                binding: 4,
-                                resource: res.uniform.as_entire_binding(),
-                            },
-                        ],
-                    })
-                });
-                let show = [0, 1].map(|i| self.bind(device, &history[i]));
-                Some(History {
-                    size: output,
-                    history,
-                    resolve,
-                    show,
-                })
-            });
-            // New textures: no history yet.
-            self.taa_this_frame.jitter[2] = 1.0;
-            self.target = Some(WorldTarget {
-                size,
-                color,
-                depth,
-                group,
-                taa,
-            });
-        }
-        self.target
-            .as_ref()
-            .map(|t| (t.color.clone(), t.depth.clone()))
-    }
-
-    /// The size of the world's own target, when it has one.
-    pub fn size(&self) -> Option<[u32; 2]> {
-        self.target.as_ref().map(|t| t.size)
-    }
-
-    /// Bindings that copy (or anti-alias) `view` onto the screen in `finish_with`.
-    pub fn bind(&self, device: &wgpu::Device, view: &wgpu::TextureView) -> wgpu::BindGroup {
-        device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("Horizon post"),
-            layout: &self.layout,
-            entries: &[
-                wgpu::BindGroupEntry {
-                    binding: 0,
-                    resource: wgpu::BindingResource::TextureView(view),
-                },
-                wgpu::BindGroupEntry {
-                    binding: 1,
-                    resource: wgpu::BindingResource::Sampler(&self.sampler),
-                },
-            ],
-        })
-    }
-
-    /// Draw the scaled world onto `screen`, through TAA when this frame's `jitter` had it on.
-    pub fn finish(
-        &self,
-        queue: &wgpu::Queue,
-        encoder: &mut wgpu::CommandEncoder,
-        screen: &wgpu::TextureView,
-    ) {
-        let Some(target) = &self.target else { return };
-        let Some(taa) = target.taa.as_ref().filter(|_| self.taa_previous.is_some()) else {
-            self.finish_with(encoder, screen, &target.group);
-            return;
-        };
-        let Some(res) = &self.taa_resources else {
-            self.finish_with(encoder, screen, &target.group);
-            return;
-        };
-        let i = (self.taa_frame % 2) as usize;
-        queue.write_buffer(&res.uniform, 0, bytemuck::bytes_of(&self.taa_this_frame));
-        let attachments = [Some(wgpu::RenderPassColorAttachment {
-            view: &taa.history[i],
-            resolve_target: None,
-            depth_slice: None,
-            ops: wgpu::Operations {
-                load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
-                store: wgpu::StoreOp::Store,
-            },
-        })];
-        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-            label: Some("Horizon TAA"),
-            color_attachments: &attachments,
-            ..Default::default()
-        });
-        pass.set_pipeline(&res.pipeline);
-        pass.set_bind_group(0, &taa.resolve[i], &[]);
-        pass.draw(0..3, 0..1);
-        drop(pass);
-        self.finish_with(encoder, screen, &taa.show[i]);
-    }
-
-    /// Draw what `group` binds (`bind`) onto `screen`.
-    pub fn finish_with(
-        &self,
-        encoder: &mut wgpu::CommandEncoder,
-        screen: &wgpu::TextureView,
-        group: &wgpu::BindGroup,
-    ) {
-        let attachments = [Some(wgpu::RenderPassColorAttachment {
-            view: screen,
-            resolve_target: None,
-            depth_slice: None,
-            ops: wgpu::Operations {
-                load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
-                store: wgpu::StoreOp::Store,
-            },
-        })];
-        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-            label: Some("Horizon post"),
-            color_attachments: &attachments,
-            ..Default::default()
-        });
-        pass.set_pipeline(if self.antialias {
-            &self.fxaa
-        } else {
-            &self.copy
-        });
-        pass.set_bind_group(0, group, &[]);
-        pass.draw(0..3, 0..1);
-    }
-}
-
-/// This frame's clip space to the previous frame's, for camera-relative projections:
-/// a point `camera - previous_camera` further from the previous camera than from this one.
-fn reprojection(previous: DMat4, previous_camera: DVec3, current: DMat4, camera: DVec3) -> DMat4 {
-    previous * DMat4::from_translation(camera - previous_camera) * current.inverse()
-}
-
-/// The radical inverse of `i` in `base`: a low-discrepancy sequence in 0..1.
-fn halton(mut i: u32, base: u32) -> f32 {
-    let (mut f, mut r) = (1.0, 0.0);
-    while i > 0 {
-        f /= base as f32;
-        r += f * (i % base) as f32;
-        i /= base;
-    }
-    r
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn reprojection_finds_where_a_block_was_last_frame() {
-        let projection = DMat4::perspective_rh(1.2, 16.0 / 9.0, 1024.0, 0.05);
-        let previous = projection * DMat4::from_rotation_y(0.3);
-        let current = projection * DMat4::from_rotation_y(0.35);
-        let (previous_camera, camera) = (DVec3::new(10.0, 64.0, 5.0), DVec3::new(10.5, 64.2, 4.0));
-        let block = DVec3::new(14.0, 66.0, -8.0);
-        let clip = |m: DMat4, eye: DVec3| m * (block - eye).extend(1.0);
-        let now = clip(current, camera);
-        let then = reprojection(previous, previous_camera, current, camera) * (now / now.w);
-        let expected = clip(previous, previous_camera);
-        assert!((then.truncate() / then.w - expected.truncate() / expected.w).length() < 1e-9);
-    }
-
-    #[test]
-    fn jitter_stays_inside_the_pixel() {
-        for i in 1..=8 {
-            let (x, y) = (halton(i, 2), halton(i, 3));
-            assert!((0.0..1.0).contains(&x) && (0.0..1.0).contains(&y));
-        }
-        assert_eq!(
-            [halton(1, 2), halton(2, 2), halton(3, 2)],
-            [0.5, 0.25, 0.75]
-        );
-    }
-
-    fn test_device() -> Option<(wgpu::Device, wgpu::Queue)> {
-        let instance =
-            wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle().with_env());
-        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
-        pollster::block_on(adapter.request_device(&Default::default())).ok()
-    }
-
-    #[test]
-    fn world_post_pipelines_compile_or_fall_back() {
-        let Some((device, _)) = test_device() else {
-            return;
-        };
-        let post = Post::new(&device, wgpu::TextureFormat::Rgba8Unorm);
-        // Copy and FXAA pipelines always compile; TAA compiles if supported by backend.
-        let _ = post.supports_taa();
-    }
-}

crates/horizon-client-render/src/hdr.wgsl

@@ -1,147 +0,0 @@
-// Horizon's HDR output pass: the frame, drawn as without HDR in vanilla's gamma
-// space, decoded to linear light at the paper white and written to the swapchain:
-// HDR10 (BT.2020, PQ) or scRGB (1.0 = 80 nits). Bright pixels of light sources that still show the
-// world as it was before the hand and HUD are expanded towards the peak.
-@group(0) @binding(0) var frame: texture_2d<f32>;
-@group(0) @binding(1) var world: texture_2d<f32>;
-
-struct Params {
-    // Paper white in scRGB units (nits / 80).
-    paper: f32,
-    // Peak brightness relative to paper white; 1 expands nothing.
-    peak: f32,
-    // 1 when this frame drew a world.
-    world: f32,
-    // 1 greys what isn't expanded and tints what is (HORIZON_HDR_DEBUG=1).
-    debug: f32,
-    // 1 for an HDR10 swapchain, 0 for scRGB.
-    pq: f32,
-    // The display's black level in nits; 0 leaves the picture as it is.
-    black: f32,
-    // The HUD and menus' brightness as a share of paper white.
-    ui: f32,
-    // Per tier, low to very bright (hdr.rs `Tier`): the share of the headroom
-    // the brightest pixels get, and the brightness where the lift starts and
-    // where it is full.
-    share: vec4<f32>,
-    start: vec4<f32>,
-    full: vec4<f32>,
-};
-@group(0) @binding(2) var<uniform> params: Params;
-
-// Light sources are lifted evenly rather than by a highlight curve: vanilla's
-// textures were drawn for SDR, so a curve on their brightest pixels blows out
-// near-white spots (glowstone) and leaves the rest (lava, a jack o'lantern's
-// face) nearly as it was. Each tier's pixels brighter than its `full` get its
-// `share` of the headroom, dimmer ones less down to none at its `start`
-// (lava's crust, a lantern's metal), and no channel goes past the peak.
-// Brightness is the mean of luminance and the brightest channel, so saturated
-// light counts as bright.
-
-// Whether `c` still shows the world pixel `w`: the same, or darkened evenly
-// across its channels, as the vignette and other screen-wide tints darken it.
-// The hand, HUD and text replace pixels instead, so they never pass. The
-// channels are held to one factor, the ratio of their sums, so a channel at 0
-// stays 0; a step of 8-bit rounding is allowed on each.
-fn shows_world(c: vec3<f32>, w: vec3<f32>) -> bool {
-    if all(c == w) {
-        return true;
-    }
-    let f = (c.r + c.g + c.b) / max(w.r + w.g + w.b, 1.0 / 255.0);
-    return f <= 1.01 && f > 0.5 && all(abs(c - f * w) <= 0.03 * w + 1.0 / 255.0);
-}
-
-// Linear BT.709 to BT.2020 (ITU-R BT.2087), columns first.
-const BT709_TO_BT2020 = mat3x3<f32>(
-    vec3(0.6274, 0.0691, 0.0164),
-    vec3(0.3293, 0.9195, 0.0880),
-    vec3(0.0433, 0.0114, 0.8956),
-);
-
-// SMPTE ST 2084: nits (up to 10000) to the PQ signal.
-fn pq(nits: vec3<f32>) -> vec3<f32> {
-    let y = pow(clamp(nits / 10000.0, vec3(0.0), vec3(1.0)), vec3(0.1593017578125));
-    return pow((0.8359375 + 18.8515625 * y) / (1.0 + 18.6875 * y), vec3(78.84375));
-}
-
-// ST 2084's inverse: the PQ signal to nits.
-fn pq_nits(e: vec3<f32>) -> vec3<f32> {
-    let p = pow(clamp(e, vec3(0.0), vec3(1.0)), vec3(1.0 / 78.84375));
-    let y = max(p - 0.8359375, vec3(0.0)) / (18.8515625 - 18.6875 * p);
-    return 10000.0 * pow(y, vec3(1.0 / 0.1593017578125));
-}
-
-// ITU-R BT.2390's black level lift (its EETF without the knee) on the PQ signal
-// `e`: black moves up to the display's black level, the peak stays, and the lift
-// fades out by the fourth power on the way up, so only the shadows move. A display
-// that can't go darker than its black level would crush everything below it.
-fn lift_black(e: vec3<f32>) -> vec3<f32> {
-    let top = pq(vec3(params.peak * params.paper * 80.0)).x;
-    let n = min(e / top, vec3(1.0));
-    return e + pq(vec3(params.black)).x * pow(vec3(1.0) - n, vec3(4.0));
-}
-
-@vertex fn vs_hdr(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
-    let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
-    return vec4(p * 2.0 - 1.0, 0.0, 1.0);
-}
-
-// Hdr::keep_world: once the world is kept, the frame's alpha starts at 0 again.
-@fragment fn fs_clear_alpha() -> @location(0) vec4<f32> {
-    return vec4(0.0);
-}
-
-@fragment fn fs_hdr(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {
-    let at = vec2<i32>(pos.xy);
-    let f = textureLoad(frame, at, 0);
-    let c = f.rgb;
-    // What covers the world here (Hdr::keep_world): nothing at 0, the hand at
-    // 1/255 (Hdr::mark_hand: drawn at the world's brightness), else the HUD or a
-    // menu, by how much.
-    let covered = f.a > 0.0;
-    let ui = select(f.a, 0.0, f.a < 1.5 / 255.0);
-    // Gamma 2.2, as SDR displays and the compositors' SDR paths decode it.
-    var light = pow(max(c, vec3(0.0)), vec3(2.2));
-    let w = textureLoad(world, at, 0);
-    // The world's alpha is below 0.75 on light sources, the sun and the moon
-    // (terrain.wgsl, the celestial pipeline): only those shine, by the tier it
-    // holds, the lower the brighter, and only where nothing was drawn over them
-    // since: grey text over the white sun still looks like the sun darkened, but
-    // it raised the frame's alpha.
-    var lifted = false;
-    if params.world > 0.5 && params.peak > 1.0 && w.a < 0.75 && !covered
-        && shows_world(c, w.rgb) {
-        // Brightness of the world pixel, before the vignette darkens the frame
-        // toward its edges: a light source shines the same anywhere on screen.
-        let wl = pow(max(w.rgb, vec3(0.0)), vec3(2.2));
-        let y = 0.5 * (dot(wl, vec3(0.2126, 0.7152, 0.0722)) + max(wl.r, max(wl.g, wl.b)));
-        let tier = u32(clamp(round(4.0 - 4.0 * w.a / 0.7), 1.0, 4.0)) - 1u;
-        let lift = smoothstep(params.start[tier], params.full[tier], y);
-        if lift > 0.0 {
-            let top = max(light.r, max(light.g, light.b));
-            let gain = min(1.0 + (params.peak - 1.0) * params.share[tier] * lift, params.peak / max(top, 1e-4));
-            light *= max(gain, 1.0);
-            lifted = true;
-        }
-    }
-    // HORIZON_HDR_DEBUG=1: what isn't lifted turns grey, what is keeps its
-    // colour with a magenta tint, so a lift shows on any colour.
-    if params.debug > 0.5 && params.world > 0.5 {
-        if lifted {
-            light *= vec3(1.0, 0.6, 1.0);
-        } else {
-            light = vec3(dot(light, vec3(0.2126, 0.7152, 0.0722)));
-        }
-    }
-    // The HUD and menus at their own brightness, by how much they cover.
-    light *= mix(1.0, params.ui, ui);
-    let scrgb = light * params.paper;
-    if params.pq > 0.5 {
-        let e = pq(BT709_TO_BT2020 * scrgb * 80.0);
-        return vec4(select(e, lift_black(e), params.black > 0.0), 1.0);
-    }
-    if params.black > 0.0 {
-        return vec4(pq_nits(lift_black(pq(scrgb * 80.0))) / 80.0, 1.0);
-    }
-    return vec4(scrgb, 1.0);
-}

crates/horizon-client-render/src/lib.rs

@@ -1,119 +0,0 @@
-//! The client's world data, rendering and screens: chunks, meshing, light, streaming, the renderer,
-//! the HUD, menus and settings. Gameplay (horizon-client) builds on it; nothing here reaches gameplay.
-#![forbid(unsafe_code)]
-pub mod assets;
-pub mod atlas_sources;
-pub mod audio;
-pub mod auth;
-pub mod bidi;
-pub mod biome;
-pub mod block_entities;
-pub mod block_entity_anim;
-pub mod block_entity_render;
-pub mod border_render;
-pub mod breaking;
-pub mod brewing;
-pub mod camera;
-pub mod chat;
-pub mod chunk;
-pub mod chunk_map;
-pub mod clouds;
-pub mod collisions;
-pub mod command_block;
-pub mod containers;
-pub mod crash;
-pub mod datapack;
-pub mod dynamic_light;
-pub mod effects;
-pub mod environment;
-pub mod extras;
-pub mod fast_hash;
-pub mod fog;
-pub mod font;
-pub mod gfx;
-pub mod graphics;
-pub mod graphics_style;
-pub mod graphics_ui;
-pub mod hud;
-pub mod hud_layout;
-pub mod hud_overlays;
-pub mod inventory_effects;
-pub mod java_text;
-pub mod level_loading;
-pub mod light;
-pub mod lod;
-pub mod logging;
-pub mod menu_blur;
-pub mod mesher;
-pub mod minimap;
-pub mod mipmap;
-pub mod mod_list;
-pub mod model_library;
-pub mod models;
-pub mod options_file;
-pub mod options_fixes;
-pub mod options_ui;
-pub mod overlay;
-pub mod pack_screen;
-pub mod packs;
-pub mod par;
-pub mod particles;
-pub mod poi_sections;
-pub mod potent_sulfur;
-pub mod providers;
-pub mod screen_draw;
-pub mod screen_effects;
-pub mod sculk;
-pub mod section_mask;
-pub mod settings;
-pub mod shader_pack_list;
-pub mod signs;
-pub mod skins;
-pub mod sound_engine;
-pub mod sound_events;
-pub mod sound_preview;
-pub mod spans;
-pub mod split_layout;
-mod sprite_cache;
-pub mod sprites;
-pub mod streaming;
-pub mod tab_list;
-pub mod telemetry;
-pub mod testgen;
-pub mod title_edition;
-pub mod trims;
-pub mod ui;
-pub mod vault;
-pub mod weather;
-pub mod widgets;
-pub mod world;
-pub mod worldborder;
-pub mod zip;
-pub use horizon_client_core::Result;
-pub use horizon_client_core::block_entity_nbt;
-pub use horizon_client_core::bossbar;
-pub use horizon_client_core::component;
-pub use horizon_client_core::fastutil_order;
-pub use horizon_client_core::gamerules;
-pub use horizon_client_core::lang;
-pub use horizon_client_core::nbt_path;
-pub use horizon_client_core::scoreboard;
-pub use horizon_client_core::snbt;
-pub use horizon_client_core::text;
-pub use horizon_client_input::clipboard;
-pub use horizon_client_input::gamepad;
-pub use horizon_client_input::input;
-pub use horizon_client_input::interaction_input;
-pub use horizon_client_input::key_names;
-pub use horizon_client_input::keybinds;
-pub use horizon_client_input::keymapping;
-pub use horizon_client_input::mouse;
-pub use horizon_client_input::window;
-pub use horizon_command as command;
-pub use horizon_items::blocks;
-pub use horizon_items::bundle;
-pub use horizon_items::cooldowns;
-pub use horizon_items::enchant;
-pub use horizon_items::item_data;
-pub use horizon_items::items;
-pub use horizon_items::random_sequences;

crates/horizon-client-render/src/potent_sulfur.rs

@@ -1,119 +0,0 @@
-//! `PotentSulfurBlockEntity`'s reads of the level: where the noxious gas of a
-//! potent sulfur block comes out, how far a geyser throws, and whether the gas
-//! reaches a point. The client's particles and the server's nausea and
-//! launches read the level the same way, through a [`ParticleLevel`].
-use crate::{blocks::Fluid, collisions::SceneCollisions, particles::ParticleLevel};
-use horizon_core::{
-    geometry::{Vec3, traverse_blocks},
-    position::BlockPos,
-};
-
-/// `PotentSulfurBlock.ALLOWED_WATER_BLOCKS_ABOVE`.
-const ALLOWED_WATER_BLOCKS_ABOVE: i32 = 4;
-
-/// `PotentSulfurBlockEntity.isGeyserPassableBlock`: air, water, or a block
-/// with no collision shape.
-pub fn is_geyser_passable_block(level: &ParticleLevel, pos: [i32; 3]) -> bool {
-    let state = level.world.block(pos[0], pos[1], pos[2]);
-    if level.facts.is_air(state) || &*level.facts.get(state).name == "minecraft:water" {
-        return true;
-    }
-    let mut scene = SceneCollisions {
-        world: level.world,
-        binding: level.collision,
-        subject: None,
-    };
-    match level.collision.collision_shape(&mut scene, state, pos) {
-        Ok(shape) => shape.is_empty(),
-        Err(_) => !level.facts.get(state).full_collision,
-    }
-}
-
-/// `PotentSulfurBlockEntity.isWater`: the block at `pos` holds a water source
-/// (`FluidState.isSourceOfType`).
-fn is_water_source(level: &ParticleLevel, pos: [i32; 3]) -> bool {
-    let (fluid, source) = level.fluid_source(pos);
-    fluid == Fluid::Water && source
-}
-
-/// `PotentSulfurBlockEntity.findNoxiousGasSourceBlock`: the first block above
-/// the sulfur, within the water column's reach, that is not water-filled and
-/// lets gas through; None when something solid or a deeper column stops it.
-pub fn find_noxious_gas_source_block(level: &ParticleLevel, origin: [i32; 3]) -> Option<[i32; 3]> {
-    let max_y = origin[1] + ALLOWED_WATER_BLOCKS_ABOVE + 1;
-    let mut pos = [origin[0], origin[1] + 1, origin[2]];
-    while pos[1] <= max_y {
-        let state = level.world.block(pos[0], pos[1], pos[2]);
-        let is_water_block = &*level.facts.get(state).name == "minecraft:water";
-        if !is_water_source(level, pos)
-            || (!is_water_block && !is_geyser_passable_block(level, pos))
-        {
-            if level.facts.is_air(state) || is_geyser_passable_block(level, pos) {
-                return Some(pos);
-            }
-            break;
-        }
-        pos[1] += 1;
-    }
-    None
-}
-
-/// `PotentSulfurBlockEntity.getUnobstructedBlockCount`: how many blocks from
-/// `pos` up, at most six per water block, a geyser's push goes through.
-pub fn unobstructed_block_count(level: &ParticleLevel, pos: [i32; 3], water_blocks: i32) -> i32 {
-    let geyser_force_height = 6 * water_blocks;
-    for i in 0..geyser_force_height {
-        if !is_geyser_passable_block(level, [pos[0], pos[1] + i, pos[2]]) {
-            return i;
-        }
-    }
-    geyser_force_height
-}
-
-/// `PotentSulfurBlockEntity.canBeReachedByNoxiousGas`: `pos` is in a block gas
-/// can enter, within three blocks of the source block's centre, and above
-/// water the source's water can be seen from.
-pub fn can_be_reached_by_noxious_gas(
-    level: &ParticleLevel,
-    source_block: [i32; 3],
-    pos: [f64; 3],
-) -> bool {
-    let block = ParticleLevel::block_at(pos);
-    if !is_geyser_passable_block(level, block) {
-        return false;
-    }
-    let center = source_block.map(|c| f64::from(c) + 0.5);
-    let distance_sqr =
-        (center[0] - pos[0]).powi(2) + (center[1] - pos[1]).powi(2) + (center[2] - pos[2]).powi(2);
-    if distance_sqr > 9.0 {
-        return false;
-    }
-    let below_source = [center[0], f64::from(source_block[1] - 1) + 0.5, center[2]];
-    let below_pos = [pos[0], pos[1] - 1.0, pos[2]];
-    is_water_source(level, ParticleLevel::block_at(below_pos))
-        && have_line_of_sight(level, below_source, below_pos)
-}
-
-/// `PotentSulfurBlockEntity.haveLineOfSight`: a clip over collider shapes and
-/// no fluids (as the mobs' line of sight does) finds no block between the
-/// points.
-fn have_line_of_sight(level: &ParticleLevel, a: [f64; 3], b: [f64; 3]) -> bool {
-    let (from, to) = (Vec3::new(a[0], a[1], a[2]), Vec3::new(b[0], b[1], b[2]));
-    let mut scene = SceneCollisions {
-        world: level.world,
-        binding: level.collision,
-        subject: None,
-    };
-    let hit = traverse_blocks(from, to, 512, |p: BlockPos| {
-        let state = level.world.block(p.x, p.y, p.z);
-        if level.facts.is_air(state) {
-            return None;
-        }
-        let shape = level
-            .collision
-            .collision_shape(&mut scene, state, [p.x, p.y, p.z])
-            .ok()?;
-        shape.clip(from, to, p).map(|_| ())
-    });
-    !matches!(hit, Ok(Some(())))
-}

crates/horizon-client-render/src/providers.rs

@@ -1,122 +0,0 @@
-//! Vanilla's `context_int_provider` and `context_float_provider` values (furnace
-//! fuel times, brewing times), evaluated from the data pack's JSON.
-use crate::items::{ItemStack, Items};
-use serde_json::Value;
-use std::{collections::HashMap, fs, path::Path};
-
-/// Evaluator for `context_int_provider` / `context_float_provider` values.
-pub struct Providers {
-    ints: HashMap<String, Value>,
-    floats: HashMap<String, Value>,
-}
-fn load_dir(dir: &Path, prefix: &str, out: &mut HashMap<String, Value>) {
-    let Ok(entries) = fs::read_dir(dir) else {
-        return;
-    };
-    for e in entries.flatten() {
-        let p = e.path();
-        let name = p
-            .file_stem()
-            .and_then(|s| s.to_str())
-            .unwrap_or("")
-            .to_owned();
-        if p.is_dir() {
-            load_dir(&p, &format!("{prefix}{name}/"), out);
-        } else if let Ok(bytes) = fs::read(&p)
-            && let Ok(v) = serde_json::from_slice(&bytes)
-        {
-            out.insert(format!("minecraft:{prefix}{name}"), v);
-        }
-    }
-}
-impl Providers {
-    pub fn load(root: &Path) -> Self {
-        let mut ints = HashMap::new();
-        let mut floats = HashMap::new();
-        load_dir(
-            &root.join("data/minecraft/context_int_provider"),
-            "",
-            &mut ints,
-        );
-        load_dir(
-            &root.join("data/minecraft/context_float_provider"),
-            "",
-            &mut floats,
-        );
-        Self { ints, floats }
-    }
-    fn eval(v: &Value, fast: bool, table: &HashMap<String, Value>, depth: u32) -> f64 {
-        if depth > 16 {
-            return 0.0;
-        }
-        match v {
-            Value::Number(n) => n.as_f64().unwrap_or(0.0),
-            Value::String(name) => table
-                .get(name)
-                .map_or(0.0, |v| Self::eval(v, fast, table, depth + 1)),
-            Value::Object(o) => {
-                let f =
-                    |k: &str| Self::eval(o.get(k).unwrap_or(&Value::Null), fast, table, depth + 1);
-                match o.get("type").and_then(Value::as_str).unwrap_or("") {
-                    "minecraft:div" => {
-                        let r = f("right");
-                        if r == 0.0 {
-                            0.0
-                        } else {
-                            (f("left") / r).trunc()
-                        }
-                    }
-                    "minecraft:mul" => f("left") * f("right"),
-                    "minecraft:add" | "minecraft:sum" => f("left") + f("right"),
-                    "minecraft:sub" => f("left") - f("right"),
-                    "minecraft:constant" => f("value"),
-                    "minecraft:conditional" => {
-                        // The only condition in the pinned data: block/fast_cooking.
-                        let condition = o.get("condition").and_then(Value::as_str)
-                            == Some("minecraft:block/fast_cooking");
-                        if condition && fast {
-                            f("on_true")
-                        } else {
-                            f("on_false")
-                        }
-                    }
-                    _ => 0.0,
-                }
-            }
-            _ => 0.0,
-        }
-    }
-    /// A plain `context_int_provider` value or reference (no context conditions).
-    pub fn int_value(&self, v: &Value) -> i32 {
-        Self::eval(v, false, &self.ints, 0) as i32
-    }
-    /// A plain `context_float_provider` value or reference; `default` when absent.
-    pub fn float_value(&self, v: &Value, default: f32) -> f32 {
-        if v.is_null() {
-            default
-        } else {
-            Self::eval(v, false, &self.floats, 0) as f32
-        }
-    }
-    #[cfg(test)]
-    pub fn empty() -> Self {
-        Self {
-            ints: HashMap::new(),
-            floats: HashMap::new(),
-        }
-    }
-    pub fn burn_time(&self, items: &Items, stack: &ItemStack, fast: bool) -> i32 {
-        items
-            .get(&stack.item)
-            .and_then(|i| i.fuel.as_ref())
-            .map_or(0, |(time, _)| Self::eval(time, fast, &self.ints, 0) as i32)
-    }
-    pub fn speed(&self, items: &Items, stack: &ItemStack, fast: bool) -> f32 {
-        items
-            .get(&stack.item)
-            .and_then(|i| i.fuel.as_ref())
-            .map_or(1.0, |(_, speed)| {
-                Self::eval(speed, fast, &self.floats, 0) as f32
-            })
-    }
-}

crates/horizon-client-render/src/section_mask.rs

@@ -1,164 +0,0 @@
-//! Sets of section indexes in a chunk column, a bit per section.
-//!
-//! Vanilla's tallest level has 254 sections (`DimensionType.Y_SIZE / 16`), and
-//! light data adds a section below and above it: 256 bits hold every layout a
-//! dimension type allows.
-
-/// Section indexes of one column, 0 being the lowest.
-#[derive(Clone, Copy, Default, PartialEq, Eq, Hash)]
-pub struct SectionMask([u64; 4]);
-
-impl SectionMask {
-    pub const CAPACITY: usize = 256;
-    pub const EMPTY: Self = Self([0; 4]);
-    pub const ALL: Self = Self([u64::MAX; 4]);
-
-    /// The indexes `0..n`.
-    pub const fn below(n: usize) -> Self {
-        let mut words = [0; 4];
-        let mut w = 0;
-        while w < 4 {
-            let bits = n.saturating_sub(w * 64);
-            words[w] = if bits >= 64 {
-                u64::MAX
-            } else {
-                (1 << bits) - 1
-            };
-            w += 1;
-        }
-        Self(words)
-    }
-    pub fn single(i: usize) -> Self {
-        let mut mask = Self::EMPTY;
-        mask.insert(i);
-        mask
-    }
-    #[inline]
-    pub fn contains(&self, i: usize) -> bool {
-        i < Self::CAPACITY && self.0[i >> 6] >> (i & 63) & 1 != 0
-    }
-    #[inline]
-    pub fn insert(&mut self, i: usize) {
-        self.0[i >> 6] |= 1 << (i & 63);
-    }
-    #[inline]
-    pub fn remove(&mut self, i: usize) {
-        self.0[i >> 6] &= !(1 << (i & 63));
-    }
-    pub fn is_empty(&self) -> bool {
-        self.0 == [0; 4]
-    }
-    pub fn len(&self) -> usize {
-        self.0.iter().map(|w| w.count_ones() as usize).sum()
-    }
-    /// The indexes from `i` up.
-    pub fn from(self, i: usize) -> Self {
-        self & !Self::below(i)
-    }
-    /// The indexes, lowest first.
-    pub fn iter(self) -> Indexes {
-        Indexes(self)
-    }
-}
-
-impl std::ops::BitOr for SectionMask {
-    type Output = Self;
-    fn bitor(self, other: Self) -> Self {
-        Self(std::array::from_fn(|w| self.0[w] | other.0[w]))
-    }
-}
-impl std::ops::BitOrAssign for SectionMask {
-    fn bitor_assign(&mut self, other: Self) {
-        *self = *self | other;
-    }
-}
-impl std::ops::BitAnd for SectionMask {
-    type Output = Self;
-    fn bitand(self, other: Self) -> Self {
-        Self(std::array::from_fn(|w| self.0[w] & other.0[w]))
-    }
-}
-impl std::ops::Not for SectionMask {
-    type Output = Self;
-    fn not(self) -> Self {
-        Self(self.0.map(|w| !w))
-    }
-}
-impl std::fmt::Debug for SectionMask {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_set().entries(self.iter()).finish()
-    }
-}
-impl FromIterator<usize> for SectionMask {
-    fn from_iter<I: IntoIterator<Item = usize>>(indexes: I) -> Self {
-        let mut mask = Self::EMPTY;
-        for i in indexes {
-            mask.insert(i);
-        }
-        mask
-    }
-}
-
-/// `SectionMask::iter`: the set's indexes in ascending order.
-#[derive(Clone, Copy, Debug)]
-pub struct Indexes(SectionMask);
-impl Iterator for Indexes {
-    type Item = usize;
-    #[inline]
-    fn next(&mut self) -> Option<usize> {
-        let words = &mut (self.0).0;
-        let w = words.iter().position(|&w| w != 0)?;
-        let bit = words[w].trailing_zeros() as usize;
-        words[w] &= words[w] - 1;
-        Some(w * 64 + bit)
-    }
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.0.len();
-        (len, Some(len))
-    }
-}
-impl ExactSizeIterator for Indexes {}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn sets_across_words() {
-        let mut mask = SectionMask::EMPTY;
-        for i in [0, 23, 63, 64, 130, 255] {
-            mask.insert(i);
-        }
-        assert_eq!(mask.iter().collect::<Vec<_>>(), [0, 23, 63, 64, 130, 255]);
-        assert_eq!(mask.len(), 6);
-        assert!(mask.contains(130) && !mask.contains(131) && !mask.contains(300));
-        mask.remove(64);
-        assert_eq!(mask.from(24).iter().collect::<Vec<_>>(), [63, 130, 255]);
-        assert_eq!(mask.from(256), SectionMask::EMPTY);
-        assert_eq!(mask.from(0), mask);
-        assert!(SectionMask::EMPTY.is_empty() && !mask.is_empty());
-    }
-
-    #[test]
-    fn below_counts_whole_and_partial_words() {
-        for n in [0, 1, 24, 63, 64, 65, 131, 254, 256] {
-            let mask = SectionMask::below(n);
-            assert_eq!(mask.len(), n);
-            assert_eq!(mask.iter().collect::<Vec<_>>(), (0..n).collect::<Vec<_>>());
-        }
-        assert_eq!(SectionMask::below(1000), SectionMask::ALL);
-    }
-
-    #[test]
-    fn operators() {
-        let a: SectionMask = [1, 70, 200].into_iter().collect();
-        let b: SectionMask = [70, 3].into_iter().collect();
-        assert_eq!((a | b).iter().collect::<Vec<_>>(), [1, 3, 70, 200]);
-        assert_eq!((a & b).iter().collect::<Vec<_>>(), [70]);
-        assert_eq!(
-            (!a & SectionMask::below(4)).iter().collect::<Vec<_>>(),
-            [0, 2, 3]
-        );
-        assert_eq!(format!("{a:?}"), "{1, 70, 200}");
-    }
-}

crates/horizon-client-render/src/sound_preview.rs

@@ -1,179 +0,0 @@
-//! `SoundPreviewHandler`: the sound a category volume slider plays while it
-//! moves on the title screen's options (`Options.createSoundSliderOptionInstance`
-//! calls `preview` when there is no level).
-use crate::settings::SOUND_SOURCES;
-use crate::sound_engine::{InstanceId, SoundEngine, SoundInstance, Sounds};
-
-/// The sound `SoundPreviewHandler.preview` plays for a `SoundSource` index,
-/// or `None` (`SoundEvents.EMPTY`) for master, music and voice.
-pub fn preview_event(source: usize) -> Option<&'static str> {
-    Some(match *SOUND_SOURCES.get(source)? {
-        "record" => "minecraft:block.note_block.guitar",
-        "weather" => "minecraft:entity.lightning_bolt.thunder",
-        "block" => "minecraft:block.grass.place",
-        "hostile" => "minecraft:entity.zombie.ambient",
-        // SoundEvents.COW_SOUNDS.get(CowSoundVariants.SoundSet.CLASSIC).ambientSound()
-        "neutral" => "minecraft:entity.cow.ambient",
-        "player" => "minecraft:entity.generic.eat",
-        "ambient" => "minecraft:ambient.cave",
-        "ui" => "minecraft:ui.button.click",
-        _ => return None,
-    })
-}
-
-/// `SoundPreviewHandler`'s `activePreview` and `previousCategory`.
-#[derive(Debug, Default)]
-pub struct SoundPreview {
-    active: Option<InstanceId>,
-    previous: Option<usize>,
-}
-
-impl SoundPreview {
-    /// `SoundPreviewHandler.preview(soundManager, category, volume)`: stop the
-    /// preview of another category, then, unless the last preview still
-    /// plays, play this category's sound (`SimpleSoundInstance.forUI` at
-    /// pitch 1 and the slider's volume).
-    pub fn preview(&mut self, sounds: &mut impl Sounds, source: usize, volume: f32) {
-        self.stop_other_category_preview(sounds, source);
-        if !self.can_play_sound(sounds) {
-            return;
-        }
-        let Some(event) = preview_event(source) else {
-            return;
-        };
-        if let Some(old) = self.active.take() {
-            sounds.release(old);
-        }
-        let instance = SoundInstance::for_ui(event, 1.0, volume, SoundEngine::unseeded());
-        self.active = Some(sounds.play_instance(instance, true).0);
-    }
-
-    /// The preview playing now, if any.
-    pub fn active(&self) -> Option<InstanceId> {
-        self.active
-    }
-
-    /// `stopOtherCategoryPreview`.
-    fn stop_other_category_preview(&mut self, sounds: &mut impl Sounds, source: usize) {
-        if self.previous != Some(source) {
-            self.previous = Some(source);
-            if let Some(active) = self.active {
-                sounds.stop_instance(active);
-            }
-        }
-    }
-
-    /// `canPlaySound`: no preview yet, or the last one has finished.
-    fn can_play_sound(&self, sounds: &mut impl Sounds) -> bool {
-        self.active.is_none_or(|active| !sounds.is_active(active))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::sound_engine::{Bound, TickContext, UI, test_backend::Null};
-    use crate::sound_events::SoundRegistry;
-
-    fn engine() -> SoundEngine {
-        let mut registry = SoundRegistry::default();
-        registry.add_file(
-            "minecraft",
-            br#"{"entity.zombie.ambient": {"sounds": ["mob/zombie/say1"]},
-                 "entity.cow.ambient": {"sounds": ["mob/cow/say1"]},
-                 "ui.button.click": {"sounds": ["random/click"]}}"#,
-            &|_, _| true,
-        );
-        SoundEngine::new(registry)
-    }
-
-    fn source(name: &str) -> usize {
-        SOUND_SOURCES.iter().position(|s| *s == name).unwrap()
-    }
-
-    #[test]
-    fn each_category_previews_its_vanilla_sound() {
-        let expected = [
-            ("master", None),
-            ("music", None),
-            ("record", Some("minecraft:block.note_block.guitar")),
-            ("weather", Some("minecraft:entity.lightning_bolt.thunder")),
-            ("block", Some("minecraft:block.grass.place")),
-            ("hostile", Some("minecraft:entity.zombie.ambient")),
-            ("neutral", Some("minecraft:entity.cow.ambient")),
-            ("player", Some("minecraft:entity.generic.eat")),
-            ("ambient", Some("minecraft:ambient.cave")),
-            ("voice", None),
-            ("ui", Some("minecraft:ui.button.click")),
-        ];
-        for (name, event) in expected {
-            assert_eq!(preview_event(source(name)), event, "{name}");
-        }
-    }
-
-    fn slide(
-        preview: &mut SoundPreview,
-        engine: &mut SoundEngine,
-        backend: &mut Null,
-        name: &str,
-        volume: f32,
-    ) {
-        preview.preview(&mut Bound { engine, backend }, source(name), volume);
-    }
-
-    /// Ticks enough for the engine to drop finished or stopped channels.
-    fn settle(engine: &mut SoundEngine, backend: &mut Null) {
-        for _ in 0..40 {
-            engine.tick(false, &TickContext::default(), backend);
-        }
-    }
-
-    #[test]
-    fn a_moving_slider_plays_one_preview_at_a_time_and_switching_stops_it() {
-        let (mut engine, mut backend) = (engine(), Null::default());
-        let mut preview = SoundPreview::default();
-        slide(&mut preview, &mut engine, &mut backend, "hostile", 0.4);
-        let first = preview
-            .active()
-            .expect("the hostile slider plays a preview");
-        let instance = engine.instance(first).unwrap();
-        assert_eq!(instance.identifier, "minecraft:entity.zombie.ambient");
-        assert_eq!(instance.source, UI);
-        assert_eq!((instance.volume, instance.pitch), (0.4, 1.0));
-        assert!(instance.relative);
-        assert!(engine.is_active(first));
-        // canPlaySound: still playing, so dragging further does not restart it.
-        slide(&mut preview, &mut engine, &mut backend, "hostile", 0.6);
-        assert_eq!(preview.active(), Some(first));
-        assert_eq!(engine.active_instances(), vec![first]);
-        // Once it has finished, the next move plays it again.
-        for stopped in backend.stopped.values_mut() {
-            *stopped = true;
-        }
-        settle(&mut engine, &mut backend);
-        assert!(!engine.is_active(first));
-        slide(&mut preview, &mut engine, &mut backend, "hostile", 0.6);
-        let second = preview.active().unwrap();
-        assert_ne!(second, first);
-        assert!(engine.is_active(second));
-        // Another category stops the playing preview (SoundManager.stop); the
-        // engine lets its channel go on the next ticks, then that category's
-        // own sound plays.
-        slide(&mut preview, &mut engine, &mut backend, "neutral", 1.0);
-        assert!(backend.stopped.values().all(|stopped| *stopped));
-        settle(&mut engine, &mut backend);
-        assert!(engine.active_instances().is_empty());
-        slide(&mut preview, &mut engine, &mut backend, "neutral", 1.0);
-        let third = preview.active().unwrap();
-        assert_eq!(
-            engine.instance(third).unwrap().identifier,
-            "minecraft:entity.cow.ambient"
-        );
-        // Master has no sound but still stops the other category's preview.
-        slide(&mut preview, &mut engine, &mut backend, "master", 1.0);
-        settle(&mut engine, &mut backend);
-        assert!(engine.active_instances().is_empty());
-        slide(&mut preview, &mut engine, &mut backend, "master", 1.0);
-        assert!(engine.active_instances().is_empty());
-    }
-}

crates/horizon-client-render/src/split_layout.rs

@@ -1,272 +0,0 @@
-//! Splitscreen's layout, pure data tested without a window: where each player's view goes in
-//! its window (`place`).
-use winit::dpi::PhysicalSize;
-
-/// Players at most: P1 and fifteen more.
-pub const MAX_PLAYERS: usize = 16;
-
-/// A player's view: its window (an index into the windows), its corner there and its size.
-pub type View = (usize, [u32; 2], PhysicalSize<u32>);
-
-/// Rows of five to sixteen players sharing a window, widest first (columns on a tall window): every
-/// view stays near a screen's shape, where a full grid would leave a long thin one.
-const ROWS: [&[u32]; MAX_PLAYERS - 4] = [
-    &[3, 2],
-    &[3, 3],
-    &[3, 2, 2],
-    &[3, 3, 2],
-    &[3, 3, 3],
-    &[4, 3, 3],
-    &[4, 4, 3],
-    &[4, 4, 4],
-    &[4, 3, 3, 3],
-    &[4, 4, 3, 3],
-    &[4, 4, 4, 3],
-    &[4, 4, 4, 4],
-];
-
-/// `order` made a whole order of `n` players: those it names (once, if there are), then the
-/// others, P1 first.
-pub fn ordered(order: &[usize], n: usize) -> Vec<usize> {
-    let mut out: Vec<usize> = Vec::with_capacity(n);
-    for &i in order {
-        if i < n && !out.contains(&i) {
-            out.push(i);
-        }
-    }
-    out.extend((0..n).filter(|i| !order.contains(i)));
-    out
-}
-
-/// `place` with the players sharing a window in `order` (`ordered`): the first left or on top.
-/// The views are still by player.
-pub fn place_ordered(
-    windows: &[usize],
-    order: &[usize],
-    sizes: &[PhysicalSize<u32>],
-    two: u8,
-    three: u8,
-) -> Vec<View> {
-    let order = ordered(order, windows.len());
-    let in_order: Vec<usize> = order.iter().map(|&i| windows[i]).collect();
-    let placed = place(&in_order, sizes, two, three);
-    let mut views = placed.clone();
-    for (k, &i) in order.iter().enumerate() {
-        views[i] = placed[k];
-    }
-    views
-}
-
-/// Each player's view, given the window each is in and the windows' sizes. Players in one window
-/// share it in the order they come: two take halves (`two`: 0 side by side when wider than
-/// tall, 1 side by side, 2 top and bottom); three (`three`: 0 the first wide on top and two below,
-/// 1 the first tall on the left and two on the right, 2 three columns); four its quarters; five
-/// to sixteen in balanced rows (`ROWS`).
-pub fn place(windows: &[usize], sizes: &[PhysicalSize<u32>], two: u8, three: u8) -> Vec<View> {
-    windows
-        .iter()
-        .enumerate()
-        .map(|(i, &window)| {
-            let here = windows.iter().filter(|&&w| w == window).count();
-            let slot = windows[..i].iter().filter(|&&w| w == window).count() as u32;
-            let size = sizes
-                .get(window)
-                .copied()
-                .unwrap_or(PhysicalSize::new(1, 1));
-            let (w, h) = (size.width, size.height);
-            let side_by_side = match two {
-                1 => true,
-                2 => false,
-                _ => w >= h,
-            };
-            // The view's cell as fractions of the window: (x0, x1, y0, y1) in halves or thirds.
-            let cell = |x0: u32, x1: u32, y0: u32, y1: u32, of: u32| {
-                [w * x0 / of, w * x1 / of, h * y0 / of, h * y1 / of]
-            };
-            let [x0, x1, y0, y1] = match (here, slot) {
-                (1, _) => cell(0, 1, 0, 1, 1),
-                (2, s) if side_by_side => cell(s, s + 1, 0, 2, 2),
-                (2, s) => cell(0, 2, s, s + 1, 2),
-                (3, s) => match (three, s) {
-                    (2, s) => cell(s, s + 1, 0, 3, 3),
-                    (1, 0) => cell(0, 1, 0, 2, 2),
-                    (1, s) => cell(1, 2, s - 1, s, 2),
-                    (_, 0) => cell(0, 2, 0, 1, 2),
-                    (_, s) => cell(s - 1, s, 1, 2, 2),
-                },
-                (4, s) => cell(s % 2, s % 2 + 1, s / 2, s / 2 + 1, 2),
-                (n, s) => rows(n, s, w, h),
-            };
-            (
-                window,
-                [x0, y0],
-                PhysicalSize::new((x1 - x0).max(1), (y1 - y0).max(1)),
-            )
-        })
-        .collect()
-}
-
-/// Five to sixteen players: `slot`'s cell `[x0, x1, y0, y1]` in balanced rows (`ROWS`), or
-/// in columns when the window is taller than wide.
-fn rows(n: usize, slot: u32, w: u32, h: u32) -> [u32; 4] {
-    let counts = ROWS[n.clamp(5, MAX_PLAYERS) - 5];
-    let bands = counts.len() as u32;
-    let (mut band, mut k) = (0, slot);
-    while band + 1 < bands && k >= counts[band as usize] {
-        k -= counts[band as usize];
-        band += 1;
-    }
-    let across = counts[band as usize];
-    // Along: the long side, divided between a band's views; down: the bands.
-    let (along, down) = if w >= h { (w, h) } else { (h, w) };
-    let (a0, a1) = (along * k / across, along * (k + 1) / across);
-    let (d0, d1) = (down * band / bands, down * (band + 1) / bands);
-    if w >= h {
-        [a0, a1, d0, d1]
-    } else {
-        [d0, d1, a0, a1]
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn size(w: u32, h: u32) -> PhysicalSize<u32> {
-        PhysicalSize::new(w, h)
-    }
-
-    #[test]
-    fn players_on_one_screen_share_it() {
-        let wide = [size(1920, 1080)];
-        assert_eq!(
-            place(&[0, 0], &wide, 0, 0)[1],
-            (0, [960, 0], size(960, 1080))
-        );
-        assert_eq!(
-            place(&[0, 0], &wide, 2, 0)[1],
-            (0, [0, 540], size(1920, 540))
-        );
-        // Auto on a tall screen: top and bottom.
-        assert_eq!(place(&[0, 0], &[size(1080, 1920)], 0, 0)[1].1, [0, 960]);
-        assert_eq!(
-            place(&[0; 4], &wide, 0, 0)[3],
-            (0, [960, 540], size(960, 540))
-        );
-    }
-
-    #[test]
-    fn desk_and_couch() {
-        // P1 alone at the desk; P2 and P3 share the TV.
-        let screens = [size(3024, 1964), size(3840, 2160)];
-        let views = place(&[0, 1, 1], &screens, 0, 0);
-        assert_eq!(views[0], (0, [0, 0], size(3024, 1964)));
-        assert_eq!(views[1], (1, [0, 0], size(1920, 2160)));
-        assert_eq!(views[2], (1, [1920, 0], size(1920, 2160)));
-    }
-
-    #[test]
-    fn three_on_a_screen() {
-        let tv = [size(1920, 1080)];
-        // One wide on top, two below.
-        let top = place(&[0; 3], &tv, 0, 0);
-        assert_eq!(top[0], (0, [0, 0], size(1920, 540)));
-        assert_eq!(top[2], (0, [960, 540], size(960, 540)));
-        // One tall on the left, two stacked on the right.
-        let left = place(&[0; 3], &tv, 0, 1);
-        assert_eq!(left[0], (0, [0, 0], size(960, 1080)));
-        assert_eq!(left[2], (0, [960, 540], size(960, 540)));
-        // Three columns.
-        assert_eq!(
-            place(&[0; 3], &tv, 0, 2)[2],
-            (0, [1280, 0], size(640, 1080))
-        );
-    }
-
-    #[test]
-    fn two_windows_two_players_each() {
-        // P1 and P2 at the desk, P3 and P4 on the TV: halves in each window.
-        let screens = [size(3024, 1964), size(3840, 2160)];
-        let views = place(&[0, 0, 1, 1], &screens, 0, 0);
-        assert_eq!(views[1], (0, [1512, 0], size(1512, 1964)));
-        assert_eq!(views[2], (1, [0, 0], size(1920, 2160)));
-        assert_eq!(views[3], (1, [1920, 0], size(1920, 2160)));
-    }
-
-    #[test]
-    fn five_to_eight_in_rows_of_three_and_two() {
-        let tv = [size(1920, 1080)];
-        let eight = place(&[0; 8], &tv, 0, 0);
-        assert_eq!(eight[0], (0, [0, 0], size(640, 360)));
-        assert_eq!(eight[5], (0, [1280, 360], size(640, 360)));
-        assert_eq!(eight[7], (0, [960, 720], size(960, 360)));
-        let seven = place(&[0; 7], &tv, 0, 0);
-        assert_eq!(seven[3], (0, [0, 360], size(960, 360)));
-        // Every count tiles the window exactly: no gap, no overlap.
-        for n in 5..=MAX_PLAYERS {
-            for screen in [size(1920, 1080), size(1080, 1920), size(1711, 997)] {
-                let views = place(&vec![0; n], &[screen], 0, 0);
-                for (i, (_, [x, y], size)) in views.iter().enumerate() {
-                    assert!(x + size.width <= screen.width && y + size.height <= screen.height);
-                    for (_, [ox, oy], other) in &views[..i] {
-                        assert!(
-                            x + size.width <= *ox
-                                || ox + other.width <= *x
-                                || y + size.height <= *oy
-                                || oy + other.height <= *y,
-                            "overlapping views for {n} in {screen:?}"
-                        );
-                    }
-                }
-                let area: u64 = views
-                    .iter()
-                    .map(|v| u64::from(v.2.width) * u64::from(v.2.height))
-                    .sum();
-                assert_eq!(
-                    area,
-                    u64::from(screen.width) * u64::from(screen.height),
-                    "{n} in {screen:?}"
-                );
-            }
-        }
-        // A tall window: columns.
-        let tall = place(&[0; 5], &[size(1080, 1920)], 0, 0);
-        assert_eq!(tall[0], (0, [0, 0], size(540, 640)));
-        assert_eq!(tall[4], (0, [540, 960], size(540, 960)));
-    }
-
-    #[test]
-    fn sixteen_players_form_a_four_by_four_grid() {
-        let views = place(&[0; 16], &[size(3840, 2160)], 0, 0);
-        for (i, view) in views.iter().enumerate() {
-            assert_eq!(
-                *view,
-                (
-                    0,
-                    [(i as u32 % 4) * 960, (i as u32 / 4) * 540],
-                    size(960, 540)
-                )
-            );
-        }
-    }
-
-    #[test]
-    fn an_order_names_each_player_once_and_the_others_come_last() {
-        assert_eq!(ordered(&[], 3), [0, 1, 2]);
-        assert_eq!(ordered(&[2, 0], 3), [2, 0, 1]);
-        // Gone players and repeats are dropped.
-        assert_eq!(ordered(&[5, 1, 1], 3), [1, 0, 2]);
-    }
-
-    #[test]
-    fn players_sharing_a_window_fill_it_in_their_order() {
-        let wide = [size(2000, 1000)];
-        // P2 first: P2 on the left, P1 on the right.
-        let views = place_ordered(&[0, 0], &[1, 0], &wide, 0, 0);
-        assert_eq!(views[1].1, [0, 0]);
-        assert_eq!(views[0].1, [1000, 0]);
-        // P3 first of three: the wide view on top is P3's.
-        let views = place_ordered(&[0, 0, 0], &[2], &wide, 0, 0);
-        assert_eq!(views[2].2, size(2000, 500));
-    }
-}

crates/horizon-client-render/src/sprite_cache.rs

@@ -1,345 +0,0 @@
-//! Decoded block sprites kept on disk between launches (M-11): reading and
-//! decoding ~1300 small PNGs is most of `Sprites::load`. One file per resource
-//! root, valid only while the `textures` trees still have the same paths,
-//! sizes and modification times and the format version is the same; anything
-//! else (missing, corrupt, stale, unwritable) means the normal decoding path.
-use crate::mipmap::Strategy;
-use std::{
-    collections::HashMap,
-    fs,
-    hash::{DefaultHasher, Hash, Hasher},
-    path::{Path, PathBuf},
-};
-
-const MAGIC: &[u8; 4] = b"HSPR";
-/// Bump when `Decoded` or the decoding in `Sprites::decode` changes.
-const VERSION: u32 = 1;
-const FILE: &str = "horizon-sprites.cache";
-
-/// What decoding one texture gives, before it takes a layer.
-#[derive(Clone)]
-pub(crate) struct Decoded {
-    pub side: u32,
-    pub frames: Vec<Vec<u8>>,
-    /// The `.mcmeta` `animation` value, as text.
-    pub animation: Option<String>,
-    pub strategy: Strategy,
-    pub alpha_cutoff_bias: f32,
-    pub has_transparent: bool,
-    pub opaque: bool,
-    pub translucent: bool,
-}
-
-pub(crate) struct SpriteCache {
-    path: PathBuf,
-    fingerprint: u64,
-    entries: HashMap<String, Decoded>,
-    dirty: bool,
-}
-
-/// Paths, sizes and modification times of every file under `assets/*/textures`,
-/// summed so the directory order does not matter.
-fn fingerprint(root: &Path) -> Option<u64> {
-    fn walk(dir: &Path, base: &Path, sum: &mut u64) -> Option<()> {
-        for entry in fs::read_dir(dir).ok()? {
-            let entry = entry.ok()?;
-            let meta = entry.metadata().ok()?;
-            if meta.is_dir() {
-                walk(&entry.path(), base, sum)?;
-                continue;
-            }
-            let mut hasher = DefaultHasher::new();
-            entry.path().strip_prefix(base).ok()?.hash(&mut hasher);
-            meta.len().hash(&mut hasher);
-            meta.modified().ok()?.hash(&mut hasher);
-            *sum = sum.wrapping_add(hasher.finish());
-        }
-        Some(())
-    }
-    let mut sum = 0;
-    for namespace in fs::read_dir(root.join("assets")).ok()? {
-        let textures = namespace.ok()?.path().join("textures");
-        if textures.is_dir() {
-            walk(&textures, root, &mut sum)?;
-        }
-    }
-    Some(sum)
-}
-
-impl SpriteCache {
-    /// The cache of `root`: its stored entries when still valid, else empty.
-    /// `None` when the textures cannot be fingerprinted (no caching then).
-    pub fn open(root: &Path) -> Option<Self> {
-        let fingerprint = fingerprint(root)?;
-        let path = root.join(FILE);
-        let entries = fs::read(&path)
-            .ok()
-            .and_then(|bytes| parse(&bytes, fingerprint))
-            .unwrap_or_default();
-        Some(Self {
-            path,
-            fingerprint,
-            entries,
-            dirty: false,
-        })
-    }
-    pub fn get(&self, name: &str) -> Option<&Decoded> {
-        self.entries.get(name)
-    }
-    pub fn insert(&mut self, name: &str, decoded: Decoded) {
-        self.entries.insert(name.to_owned(), decoded);
-        self.dirty = true;
-    }
-    /// Write new entries; a failure only costs the next launch the decoding.
-    pub fn save(&mut self) {
-        if !self.dirty {
-            return;
-        }
-        self.dirty = false;
-        let temporary = self
-            .path
-            .with_extension(format!("{}.tmp", std::process::id()));
-        if fs::write(&temporary, serialize(self.fingerprint, &self.entries)).is_ok()
-            && fs::rename(&temporary, &self.path).is_err()
-        {
-            let _ = fs::remove_file(&temporary);
-        }
-    }
-}
-
-fn serialize(fingerprint: u64, entries: &HashMap<String, Decoded>) -> Vec<u8> {
-    let mut out = Vec::new();
-    out.extend_from_slice(MAGIC);
-    out.extend_from_slice(&VERSION.to_le_bytes());
-    out.extend_from_slice(&fingerprint.to_le_bytes());
-    out.extend_from_slice(&(entries.len() as u32).to_le_bytes());
-    for (name, d) in entries {
-        put_bytes(&mut out, name.as_bytes());
-        out.extend_from_slice(&d.side.to_le_bytes());
-        out.extend_from_slice(&(d.frames.len() as u32).to_le_bytes());
-        for frame in &d.frames {
-            put_bytes(&mut out, frame);
-        }
-        put_bytes(&mut out, d.animation.as_deref().unwrap_or("").as_bytes());
-        out.push(u8::from(d.animation.is_some()));
-        out.push(d.strategy as u8);
-        out.extend_from_slice(&d.alpha_cutoff_bias.to_bits().to_le_bytes());
-        out.push(
-            u8::from(d.has_transparent) | u8::from(d.opaque) << 1 | u8::from(d.translucent) << 2,
-        );
-    }
-    out
-}
-fn put_bytes(out: &mut Vec<u8>, bytes: &[u8]) {
-    out.extend_from_slice(&(bytes.len() as u32).to_le_bytes());
-    out.extend_from_slice(bytes);
-}
-
-struct Reader<'a>(&'a [u8]);
-impl<'a> Reader<'a> {
-    fn take(&mut self, n: usize) -> Option<&'a [u8]> {
-        let (head, tail) = self.0.split_at_checked(n)?;
-        self.0 = tail;
-        Some(head)
-    }
-    fn u32(&mut self) -> Option<u32> {
-        Some(u32::from_le_bytes(self.take(4)?.try_into().ok()?))
-    }
-    fn bytes(&mut self) -> Option<&'a [u8]> {
-        let n = self.u32()? as usize;
-        self.take(n)
-    }
-}
-fn parse(bytes: &[u8], fingerprint: u64) -> Option<HashMap<String, Decoded>> {
-    let mut r = Reader(bytes);
-    if r.take(4)? != MAGIC || r.u32()? != VERSION {
-        return None;
-    }
-    if u64::from_le_bytes(r.take(8)?.try_into().ok()?) != fingerprint {
-        return None;
-    }
-    let count = r.u32()?;
-    let mut entries = HashMap::new();
-    for _ in 0..count {
-        let name = String::from_utf8(r.bytes()?.to_vec()).ok()?;
-        let side = r.u32()?;
-        let frame_count = r.u32()?;
-        let mut frames = Vec::new();
-        for _ in 0..frame_count {
-            frames.push(r.bytes()?.to_vec());
-        }
-        let animation = String::from_utf8(r.bytes()?.to_vec()).ok()?;
-        let has_animation = r.take(1)?[0] != 0;
-        let strategy = match r.take(1)?[0] {
-            0 => Strategy::Auto,
-            1 => Strategy::Mean,
-            2 => Strategy::Cutout,
-            3 => Strategy::StrictCutout,
-            4 => Strategy::DarkCutout,
-            _ => return None,
-        };
-        let alpha_cutoff_bias = f32::from_bits(r.u32()?);
-        let flags = r.take(1)?[0];
-        let frame_len = (side as usize).checked_mul(side as usize)?.checked_mul(4)?;
-        if frames.is_empty() || frames.iter().any(|f| f.len() != frame_len) {
-            return None;
-        }
-        entries.insert(
-            name,
-            Decoded {
-                side,
-                frames,
-                animation: has_animation.then_some(animation),
-                strategy,
-                alpha_cutoff_bias,
-                has_transparent: flags & 1 != 0,
-                opaque: flags & 2 != 0,
-                translucent: flags & 4 != 0,
-            },
-        );
-    }
-    r.0.is_empty().then_some(entries)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn sample(blue: u8, animation: Option<&str>) -> Decoded {
-        Decoded {
-            side: 2,
-            frames: vec![vec![blue; 16], vec![blue + 1; 16]],
-            animation: animation.map(str::to_owned),
-            strategy: Strategy::Cutout,
-            alpha_cutoff_bias: 0.25,
-            has_transparent: true,
-            opaque: false,
-            translucent: true,
-        }
-    }
-    fn scratch(tag: &str) -> PathBuf {
-        let dir =
-            std::env::temp_dir().join(format!("horizon-sprite-cache-{tag}-{}", std::process::id()));
-        let _ = fs::remove_dir_all(&dir);
-        fs::create_dir_all(dir.join("assets/minecraft/textures/block")).unwrap();
-        dir
-    }
-    #[test]
-    fn round_trips() {
-        let mut entries = HashMap::new();
-        entries.insert("a:b".to_owned(), sample(1, Some("{\"frametime\":2}")));
-        entries.insert("a:c".to_owned(), sample(9, None));
-        let back = parse(&serialize(7, &entries), 7).unwrap();
-        for (name, d) in &entries {
-            let e = &back[name];
-            assert_eq!(
-                (d.side, &d.frames, &d.animation),
-                (e.side, &e.frames, &e.animation)
-            );
-            assert_eq!(d.alpha_cutoff_bias, e.alpha_cutoff_bias);
-            assert_eq!(
-                (d.has_transparent, d.opaque, d.translucent, d.strategy as u8),
-                (e.has_transparent, e.opaque, e.translucent, e.strategy as u8)
-            );
-        }
-    }
-    #[test]
-    fn wrong_fingerprint_truncation_and_garbage_are_misses() {
-        let mut entries = HashMap::new();
-        entries.insert("a:b".to_owned(), sample(1, None));
-        let bytes = serialize(7, &entries);
-        assert!(parse(&bytes, 8).is_none());
-        for cut in 0..bytes.len() {
-            assert!(parse(&bytes[..cut], 7).is_none(), "cut {cut}");
-        }
-        assert!(parse(b"garbage", 7).is_none());
-        let mut extra = bytes.clone();
-        extra.push(0);
-        assert!(parse(&extra, 7).is_none());
-    }
-    #[test]
-    fn changed_texture_invalidates_and_corrupt_file_is_ignored() {
-        let root = scratch("invalidate");
-        let png = root.join("assets/minecraft/textures/block/x.png");
-        fs::write(&png, b"one").unwrap();
-        let mut cache = SpriteCache::open(&root).unwrap();
-        cache.insert("minecraft:block/x", sample(1, None));
-        cache.save();
-        assert!(
-            SpriteCache::open(&root)
-                .unwrap()
-                .get("minecraft:block/x")
-                .is_some()
-        );
-        // Same length, new content and time: still stale.
-        std::thread::sleep(std::time::Duration::from_millis(30));
-        fs::write(&png, b"two").unwrap();
-        assert!(
-            SpriteCache::open(&root)
-                .unwrap()
-                .get("minecraft:block/x")
-                .is_none()
-        );
-        // A new file also invalidates.
-        let mut cache = SpriteCache::open(&root).unwrap();
-        cache.insert("minecraft:block/x", sample(1, None));
-        cache.save();
-        fs::write(root.join("assets/minecraft/textures/block/y.png"), b"y").unwrap();
-        assert!(
-            SpriteCache::open(&root)
-                .unwrap()
-                .get("minecraft:block/x")
-                .is_none()
-        );
-        // Corrupt cache file: empty, no error.
-        fs::write(root.join(FILE), b"HSPR junk").unwrap();
-        assert!(
-            SpriteCache::open(&root)
-                .unwrap()
-                .get("minecraft:block/x")
-                .is_none()
-        );
-        let _ = fs::remove_dir_all(&root);
-    }
-    fn write_png(path: &Path, rgba: [u8; 4]) {
-        let mut encoder = png::Encoder::new(fs::File::create(path).unwrap(), 16, 16);
-        encoder.set_color(png::ColorType::Rgba);
-        encoder.set_depth(png::BitDepth::Eight);
-        let pixels: Vec<u8> = rgba.iter().copied().cycle().take(16 * 16 * 4).collect();
-        encoder
-            .write_header()
-            .unwrap()
-            .write_image_data(&pixels)
-            .unwrap();
-    }
-    fn sprite_pixels(root: &Path) -> Vec<u8> {
-        let mut sprites = crate::sprites::Sprites::with_disk_cache(root);
-        sprites.insert(root, "minecraft:block/x").unwrap();
-        sprites.save_disk_cache();
-        sprites.finish();
-        sprites.pixels
-    }
-    #[test]
-    fn altered_png_is_not_served_stale_and_cache_matches_decoding() {
-        let root = scratch("stale");
-        let png = root.join("assets/minecraft/textures/block/x.png");
-        write_png(&png, [255, 0, 0, 255]);
-        let decoded = sprite_pixels(&root);
-        assert!(root.join(FILE).exists());
-        assert_eq!(
-            sprite_pixels(&root),
-            decoded,
-            "cache hit differs from decoding"
-        );
-        std::thread::sleep(std::time::Duration::from_millis(30));
-        write_png(&png, [0, 255, 0, 255]);
-        let fresh = sprite_pixels(&root);
-        assert_eq!(&fresh[..4], &[0, 255, 0, 255]);
-        // Corrupt and deleted caches fall back to decoding.
-        fs::write(root.join(FILE), b"HSPR\x01\0\0\0 junk").unwrap();
-        assert_eq!(sprite_pixels(&root), fresh);
-        fs::remove_file(root.join(FILE)).unwrap();
-        assert_eq!(sprite_pixels(&root), fresh);
-        let _ = fs::remove_dir_all(&root);
-    }
-}

crates/horizon-client-render/src/world_post.wgsl

@@ -1,133 +0,0 @@
-// Horizon's world post pass: the world, rendered at the resolution scale,
-// copied (bilinear) or anti-aliased with FXAA onto the screen before the
-// hand and HUD. Only used when a non-vanilla setting asks for it.
-@group(0) @binding(0) var world: texture_2d<f32>;
-@group(0) @binding(1) var world_sampler: sampler;
-
-struct PostOut {
-    @builtin(position) clip: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-};
-
-@vertex fn vs_post(@builtin(vertex_index) i: u32) -> PostOut {
-    let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
-    var out: PostOut;
-    out.clip = vec4(p * 2.0 - 1.0, 0.0, 1.0);
-    out.uv = vec2(p.x, 1.0 - p.y);
-    return out;
-}
-
-@fragment fn fs_copy(in: PostOut) -> @location(0) vec4<f32> {
-    // The alpha carries the emissive mark through to HDR output (hdr.wgsl).
-    return textureSampleLevel(world, world_sampler, in.uv, 0.0);
-}
-
-fn luma(c: vec3<f32>) -> f32 {
-    return dot(c, vec3(0.299, 0.587, 0.114));
-}
-
-// FXAA 3.11 (console quality): blend along the local edge direction.
-@fragment fn fs_fxaa(in: PostOut) -> @location(0) vec4<f32> {
-    let texel = 1.0 / vec2<f32>(textureDimensions(world));
-    let centre = textureSampleLevel(world, world_sampler, in.uv, 0.0);
-    let rgb_m = centre.rgb;
-    let nw = luma(textureSampleLevel(world, world_sampler, in.uv + vec2(-0.5, -0.5) * texel, 0.0).rgb);
-    let ne = luma(textureSampleLevel(world, world_sampler, in.uv + vec2(0.5, -0.5) * texel, 0.0).rgb);
-    let sw = luma(textureSampleLevel(world, world_sampler, in.uv + vec2(-0.5, 0.5) * texel, 0.0).rgb);
-    let se = luma(textureSampleLevel(world, world_sampler, in.uv + vec2(0.5, 0.5) * texel, 0.0).rgb);
-    let m = luma(rgb_m);
-    let lo = min(m, min(min(nw, ne), min(sw, se)));
-    let hi = max(m, max(max(nw, ne), max(sw, se)));
-    if hi - lo < max(0.0312, hi * 0.125) {
-        return centre;
-    }
-    var dir = vec2(-((nw + ne) - (sw + se)), (nw + sw) - (ne + se));
-    let reduce = max((nw + ne + sw + se) * 0.25 * 0.125, 1.0 / 128.0);
-    let scale = 1.0 / (min(abs(dir.x), abs(dir.y)) + reduce);
-    dir = clamp(dir * scale, vec2(-8.0), vec2(8.0)) * texel;
-    let a = 0.5 * (textureSampleLevel(world, world_sampler, in.uv + dir * (1.0 / 3.0 - 0.5), 0.0).rgb
-        + textureSampleLevel(world, world_sampler, in.uv + dir * (2.0 / 3.0 - 0.5), 0.0).rgb);
-    let b = a * 0.5 + 0.25 * (textureSampleLevel(world, world_sampler, in.uv - dir * 0.5, 0.0).rgb
-        + textureSampleLevel(world, world_sampler, in.uv + dir * 0.5, 0.0).rgb);
-    let lb = luma(b);
-    if lb < lo || lb > hi {
-        return vec4(a, centre.a);
-    }
-    return vec4(b, centre.a);
-}
-
-// TAA (`world_post.rs`): blend this frame into the history, reprojected from the
-// depth buffer through the camera's motion and clamped to this frame's 3x3
-// neighbourhood so that what moved or appeared does not ghost.
-struct Taa {
-    reproject: mat4x4<f32>,
-    // xy: this frame's jitter in clip space; z: 1 when the history is unusable.
-    jitter: vec4<f32>,
-};
-@group(0) @binding(2) var history: texture_2d<f32>;
-@group(0) @binding(3) var depth: texture_depth_2d;
-@group(0) @binding(4) var<uniform> taa: Taa;
-
-// Catmull-Rom over the history in 5 bilinear taps: sharper than one under motion.
-fn sample_history(uv: vec2<f32>) -> vec3<f32> {
-    let size = vec2<f32>(textureDimensions(history));
-    let pos = uv * size;
-    let centre = floor(pos - 0.5) + 0.5;
-    let f = pos - centre;
-    let w0 = f * (-0.5 + f * (1.0 - 0.5 * f));
-    let w1 = 1.0 + f * f * (-2.5 + 1.5 * f);
-    let w2 = f * (0.5 + f * (2.0 - 1.5 * f));
-    let w3 = f * f * (-0.5 + 0.5 * f);
-    let w12 = w1 + w2;
-    let t0 = (centre - 1.0) / size;
-    let t3 = (centre + 2.0) / size;
-    let t12 = (centre + w2 / w12) / size;
-    let c = textureSampleLevel(history, world_sampler, vec2(t12.x, t0.y), 0.0).rgb * (w12.x * w0.y)
-        + textureSampleLevel(history, world_sampler, vec2(t0.x, t12.y), 0.0).rgb * (w0.x * w12.y)
-        + textureSampleLevel(history, world_sampler, t12, 0.0).rgb * (w12.x * w12.y)
-        + textureSampleLevel(history, world_sampler, vec2(t3.x, t12.y), 0.0).rgb * (w3.x * w12.y)
-        + textureSampleLevel(history, world_sampler, vec2(t12.x, t3.y), 0.0).rgb * (w12.x * w3.y);
-    let weight = w12.x * w0.y + w0.x * w12.y + w12.x * w12.y + w3.x * w12.y + w12.x * w3.y;
-    return max(c / weight, vec3(0.0));
-}
-
-// It runs at the history's size, which upscaling makes larger than the world's.
-// The history is unjittered: each output pixel takes the world pixel whose
-// jittered sample lands nearest its centre, weighted by how near it lands.
-@fragment fn fs_taa(in: PostOut) -> @location(0) vec4<f32> {
-    let size = vec2<f32>(textureDimensions(world));
-    // The jitter moved the scene by `jitter` in clip space: where this pixel's
-    // point was drawn, in world pixels.
-    let drawn = (in.uv + taa.jitter.xy * vec2(0.5, -0.5)) * size;
-    let last = vec2<i32>(size) - 1;
-    let p = clamp(vec2<i32>(floor(drawn)), vec2(0), last);
-    let centre = textureLoad(world, p, 0);
-    var lo = centre.rgb;
-    var hi = centre.rgb;
-    // Reversed depth: the nearest of the 3x3 is the largest, and its motion keeps
-    // the edges of what is in front from trailing.
-    var near = 0.0;
-    for (var y = -1; y <= 1; y++) {
-        for (var x = -1; x <= 1; x++) {
-            let q = clamp(p + vec2(x, y), vec2(0), last);
-            let c = textureLoad(world, q, 0).rgb;
-            lo = min(lo, c);
-            hi = max(hi, c);
-            near = max(near, textureLoad(depth, q, 0));
-        }
-    }
-    let ndc = vec2(in.uv.x * 2.0 - 1.0, 1.0 - in.uv.y * 2.0);
-    let previous = taa.reproject * vec4(ndc, near, 1.0);
-    let uv = vec2(0.5, -0.5) * previous.xy / previous.w + 0.5;
-    if taa.jitter.z > 0.0 || any(uv != clamp(uv, vec2(0.0), vec2(1.0))) {
-        return vec4(centre.rgb, centre.a);
-    }
-    let past = clamp(sample_history(uv), lo, hi);
-    // How far the sample landed from this pixel's centre, in output pixels: a
-    // Gaussian of it scales the new frame's share, so that frames whose sample
-    // fell far away (most of them when upscaling) barely move the pixel.
-    let off = (drawn - (vec2<f32>(p) + 0.5)) * vec2<f32>(textureDimensions(history)) / size;
-    let share = 0.1 * exp(-2.0 * dot(off, off));
-    // The alpha carries the emissive mark through to HDR output (hdr.wgsl).
-    return vec4(mix(past, centre.rgb, share), centre.a);
-}

crates/horizon-client/Cargo.toml

@@ -10,10 +10,7 @@ description = "Horizon native development client"
 [dependencies]
 horizon-assets = { path = "../horizon-assets" }
 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" }
-horizon-items = { path = "../horizon-items" }
 horizon-core = { path = "../horizon-core" }
 # The server thread ahead of the workers (MinecraftServer.spin's Thread.setPriority).
 horizon-threads = { path = "../horizon-threads" }
@@ -44,6 +41,9 @@ serde_json = { version = "1.0.151", features = ["raw_value"] }
 # hlsl-out: the gfx.rs tests translate every shader as wgpu's DirectX 12 backend does. A normal feature,
 # not a dev-dependency's, so builds, tests and examples share one build of naga, wgpu and this crate.
 naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out"] }
+# Sound (ALSA on Linux); the `audio` feature.
+cpal = { version = "0.16", optional = true }
+symphonia = { version = "0.5", default-features = false, features = ["ogg", "vorbis"] }
 miniz_oxide = "0.8"
 ab_glyph = "0.2.32"
 log = "0.4"
@@ -54,6 +54,7 @@ horizon-theme = { path = "../horizon-theme" }
 # the anonymous "I'm playing" ping the game sends itself (`heartbeat.rs`).
 horizon-telemetry = { path = "../horizon-telemetry", default-features = false, features = ["live"] }
 horizon-bench = { path = "../horizon-bench" }
+arboard = { version = "3.6.1", default-features = false, features = ["wayland-data-control"] }
 zip = { version = "2", default-features = false, features = ["deflate"] }
 # Controllers (evdev + libudev on Linux, IOKit on macOS, Windows.Gaming.Input); the `controllers` feature.
 gilrs = { version = "0.11", optional = true }
@@ -61,15 +62,12 @@ gilrs = { version = "0.11", optional = true }
 horizon-dualsense = { path = "../horizon-dualsense", optional = true }
 # HTTPS to the Minecraft services (online-mode session join).
 ureq = { version = "2", default-features = false, features = ["tls"] }
-unicode-bidi = "0.3.18"
 
 [target.'cfg(unix)'.dependencies]
 # The server thread's CPU time per tick (`HORIZON_SPIKES`, spans.rs).
-rustix = { version = "1", default-features = false, features = ["std", "time", "process"] }
+rustix = { version = "1", default-features = false, features = ["std", "time"] }
 
 [target.'cfg(windows)'.dependencies]
-# Use the registered URI handler without routing links through Explorer/cmd.
-open = { version = "5.4.5", features = ["shellexecute-on-windows"] }
 # DirectX 12, where Vulkan has no adapter or device, or by choice (`graphicsApi`, graphics.rs).
 # Shaders compile with FXC (d3dcompiler_47.dll, part of Windows), or DXC when dxcompiler.dll is
 # on the PATH.
@@ -88,9 +86,12 @@ winresource = "0.1"
 default = ["audio", "controllers"]
 # Sound output. Without it (and `controllers`) the program links neither libasound nor libudev on
 # Linux: the server build (`--no-default-features`, released as horizon-engine; docs/server.md).
-audio = ["horizon-client-render/audio"]
+audio = ["dep:cpal"]
 # Controllers: gilrs, and the DualSense's own output. Without it only `horizon-ctl pad`'s virtual pad.
-controllers = ["dep:gilrs", "dep:horizon-dualsense", "horizon-client-input/controllers"]
+controllers = ["dep:gilrs", "dep:horizon-dualsense"]
+# Runs code mods (wasmtime and cranelift: a quarter of a clean build). On in every release build
+# (release.yml); the tests and probes don't need it. Content mods load without it.
+mods = ["horizon-mods/runtime"]
 # Records the call sites of mob random draws (`mob_ai_probe` traces).
 rng-trace = ["horizon-core/rng-trace"]
 
@@ -103,7 +104,5 @@ path = "examples/probe/main.rs"
 workspace = true
 
 [dev-dependencies]
-horizon-client-render = { path = "../horizon-client-render", features = ["test-support"] }
-horizon-items = { path = "../horizon-items", features = ["test-support"] }
 # Every WGSL shader translated as wgpu's DirectX 12 backend does (gfx.rs tests).
 naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out", "msl-out", "spv-out"] }

crates/horizon-client/assets/horizon/lang/en_us.json

@@ -11,57 +11,5 @@
   "horizon.options.look_deadzone": "Look Deadzone",
   "horizon.options.button_glyphs": "Button Glyphs",
   "horizon.options.menu_navigation": "Menu Navigation",
-  "horizon.options.on_screen_keyboard": "On-Screen Keyboard",
-  "horizon.options.chat_delay": "Chat Delay",
-  "horizon.options.lightbar.health": "Health",
-  "horizon.options.lightbar.dimension": "Dimension",
-  "horizon.options.glyphs.auto": "Auto",
-  "horizon.options.glyphs.xbox": "Xbox",
-  "horizon.options.glyphs.playstation": "PlayStation",
-  "horizon.options.glyphs.nintendo": "Nintendo",
-  "horizon.options.menu_focus": "Focus",
-  "horizon.options.menu_pointer": "Pointer",
-  "horizon.options.keyboard.auto": "Auto",
-  "horizon.options.keyboard.horizon": "Horizon",
-  "horizon.options.keyboard.steam": "Steam",
-  "horizon.options.unavailable": "This feature is not yet available in Horizon.",
-  "horizon.options.search": "Search settings...",
-  "horizon.pages.mods": "Mods",
-  "horizon.pages.shader_packs": "Shader Packs",
-  "horizon.pages.controller": "Controller Settings",
-  "horizon.pages.controller_binds": "Controller Binds",
-  "horizon.pages.extras": "Horizon Extras",
-  "horizon.pages.settings": "Horizon Settings",
-  "horizon.pages.agent": "AI Agent",
-  "horizon.pages.settings.tooltip": "Horizon's own settings: graphics, controllers, extras and mods.",
-  "horizon.pages.graphics.tooltip": "Graphics, simply: each setting says what it costs.",
-  "horizon.pages.graphics_advanced.tooltip": "Every graphics setting, Horizon's included, with what each costs.",
-  "horizon.pages.controller.tooltip": "Controllers: their buttons, sticks, vibration and menu navigation.",
-  "horizon.pages.extras.tooltip": "Optional additions, all off by default: the game stays vanilla until you turn one on.",
-  "horizon.pages.agent.tooltip": "Let your own AI agent play: horizon-ctl and MCP clients on this computer.",
-  "horizon.pages.shader_packs.tooltip": "Shader packs from the shaderpacks folder: Horizon's own and those in the shaders/ format. One runs at a time.",
-  "horizon.pages.mods.tooltip": "Mods made for Horizon, from the horizon-mods folder. Each runs in a sandbox and stays off until you turn it on.",
-  "horizon.pages.open.graphics": "Graphics...",
-  "horizon.pages.open.graphics_advanced": "Advanced Graphics...",
-  "horizon.pages.open.shader_packs": "Shader Packs...",
-  "horizon.pages.open.controller": "Controller Settings...",
-  "horizon.pages.open.extras": "Extras...",
-  "horizon.pages.open.mods": "Mods...",
-  "horizon.pages.open.agent": "AI Agent...",
-  "horizon.pages.open.horizon_graphics": "Horizon Graphics...",
-  "horizon.pages.open.controller_binds": "Controller Binds...",
-  "horizon.pages.open.horizon_settings": "Horizon Settings...",
-  "horizon.mods.empty": "No mods: put .hmod files in the horizon-mods folder",
-  "horizon.mods.stopped": " (Stopped)",
-  "horizon.mods.dev": " (Dev)",
-  "horizon.mods.settings": "Settings",
-  "horizon.mods.open_folder": "Open Mod Folder",
-  "horizon.shader_packs.empty": "No shader packs: put them in the shaderpacks folder",
-  "horizon.shader_packs.kind_horizon": " (Horizon)",
-  "horizon.agent.copy_details": "Copy Connection Details",
-  "horizon.multiplayer.join": "Join",
-  "horizon.multiplayer.cancel_reconnecting": "Cancel Reconnecting",
-  "horizon.multiplayer.join_friend": "Join a Friend",
-  "horizon.multiplayer.invite_code": "Invite Code",
-  "horizon.multiplayer.relay": "Relay (optional)"
+  "horizon.options.on_screen_keyboard": "On-Screen Keyboard"
 }

crates/horizon-client/assets/horizon/lang/pl_pl.json

@@ -1,15 +0,0 @@
-{
-  "horizon.options.controller": "Kontroler",
-  "horizon.options.vibration": "Wibracje",
-  "horizon.options.adaptive_triggers": "Adaptacyjne spusty",
-  "horizon.options.lightbar": "Pasek świetlny",
-  "horizon.options.look_sensitivity": "Czułość rozglądania",
-  "horizon.options.invert_x": "Odwróć oś X rozglądania",
-  "horizon.options.invert_y": "Odwróć oś Y rozglądania",
-  "horizon.options.sneak_button": "Przycisk skradania",
-  "horizon.options.move_deadzone": "Martwa strefa ruchu",
-  "horizon.options.look_deadzone": "Martwa strefa rozglądania",
-  "horizon.options.button_glyphs": "Symbole przycisków",
-  "horizon.options.menu_navigation": "Nawigacja po menu",
-  "horizon.options.on_screen_keyboard": "Klawiatura ekranowa"
-}

crates/horizon-client/assets/horizon/lang/ru_ru.json

@@ -11,57 +11,5 @@
   "horizon.options.look_deadzone": "Мёртвая зона обзора",
   "horizon.options.button_glyphs": "Символы кнопок",
   "horizon.options.menu_navigation": "Навигация по меню",
-  "horizon.options.on_screen_keyboard": "Экранная клавиатура",
-  "horizon.options.chat_delay": "Задержка чата",
-  "horizon.options.lightbar.health": "Здоровье",
-  "horizon.options.lightbar.dimension": "Измерение",
-  "horizon.options.glyphs.auto": "Авто",
-  "horizon.options.glyphs.xbox": "Xbox",
-  "horizon.options.glyphs.playstation": "PlayStation",
-  "horizon.options.glyphs.nintendo": "Nintendo",
-  "horizon.options.menu_focus": "Фокус",
-  "horizon.options.menu_pointer": "Указатель",
-  "horizon.options.keyboard.auto": "Авто",
-  "horizon.options.keyboard.horizon": "Horizon",
-  "horizon.options.keyboard.steam": "Steam",
-  "horizon.options.unavailable": "Эта возможность в Horizon пока недоступна.",
-  "horizon.options.search": "Поиск настроек...",
-  "horizon.pages.mods": "Моды",
-  "horizon.pages.shader_packs": "Шейдерпаки",
-  "horizon.pages.controller": "Настройки контроллера",
-  "horizon.pages.controller_binds": "Назначения кнопок контроллера",
-  "horizon.pages.extras": "Дополнения Horizon",
-  "horizon.pages.settings": "Настройки Horizon",
-  "horizon.pages.agent": "ИИ-агент",
-  "horizon.pages.settings.tooltip": "Собственные настройки Horizon: графика, контроллеры, дополнения и моды.",
-  "horizon.pages.graphics.tooltip": "Графика без лишнего: у каждой настройки написано, чего она стоит.",
-  "horizon.pages.graphics_advanced.tooltip": "Все графические настройки, включая собственные настройки Horizon, и их цена.",
-  "horizon.pages.controller.tooltip": "Контроллеры: кнопки, стики, вибрация и навигация по меню.",
-  "horizon.pages.extras.tooltip": "Дополнительные возможности, все выключены по умолчанию: игра остаётся ванильной, пока вы не включите что-то.",
-  "horizon.pages.agent.tooltip": "Пусть играет ваш ИИ-агент: horizon-ctl и MCP-клиенты на этом компьютере.",
-  "horizon.pages.shader_packs.tooltip": "Шейдерпаки из папки shaderpacks: собственные паки Horizon и паки в формате shaders/. Одновременно работает один.",
-  "horizon.pages.mods.tooltip": "Моды для Horizon из папки horizon-mods. Каждый работает в песочнице и выключен, пока вы его не включите.",
-  "horizon.pages.open.graphics": "Графика...",
-  "horizon.pages.open.graphics_advanced": "Продвинутая графика...",
-  "horizon.pages.open.shader_packs": "Шейдерпаки...",
-  "horizon.pages.open.controller": "Настройки контроллера...",
-  "horizon.pages.open.extras": "Дополнения...",
-  "horizon.pages.open.mods": "Моды...",
-  "horizon.pages.open.agent": "ИИ-агент...",
-  "horizon.pages.open.horizon_graphics": "Графика Horizon...",
-  "horizon.pages.open.controller_binds": "Назначения кнопок...",
-  "horizon.pages.open.horizon_settings": "Настройки Horizon...",
-  "horizon.mods.empty": "Модов нет: положите файлы .hmod в папку horizon-mods",
-  "horizon.mods.stopped": " (остановлен)",
-  "horizon.mods.dev": " (разработка)",
-  "horizon.mods.settings": "Настройки",
-  "horizon.mods.open_folder": "Открыть папку модов",
-  "horizon.shader_packs.empty": "Шейдерпаков нет: положите их в папку shaderpacks",
-  "horizon.shader_packs.kind_horizon": " (Horizon)",
-  "horizon.agent.copy_details": "Скопировать данные подключения",
-  "horizon.multiplayer.join": "Подключиться",
-  "horizon.multiplayer.cancel_reconnecting": "Отменить переподключение",
-  "horizon.multiplayer.join_friend": "Играть с другом",
-  "horizon.multiplayer.invite_code": "Код приглашения",
-  "horizon.multiplayer.relay": "Ретранслятор (необязательно)"
+  "horizon.options.on_screen_keyboard": "Экранная клавиатура"
 }

crates/horizon-client/assets/horizon/lang/uk_ua.json

@@ -1,15 +0,0 @@
-{
-  "horizon.options.controller": "Геймпад",
-  "horizon.options.vibration": "Вібрація",
-  "horizon.options.adaptive_triggers": "Адаптивні тригери",
-  "horizon.options.lightbar": "Світлова панель",
-  "horizon.options.look_sensitivity": "Чутливість огляду",
-  "horizon.options.invert_x": "Інвертувати огляд по X",
-  "horizon.options.invert_y": "Інвертувати огляд по Y",
-  "horizon.options.sneak_button": "Кнопка присідання",
-  "horizon.options.move_deadzone": "Мертва зона руху",
-  "horizon.options.look_deadzone": "Мертва зона огляду",
-  "horizon.options.button_glyphs": "Значки кнопок",
-  "horizon.options.menu_navigation": "Навігація в меню",
-  "horizon.options.on_screen_keyboard": "Екранна клавіатура"
-}

crates/horizon-client/examples/gameplay_decode_profile.rs

@@ -2,7 +2,7 @@
 //! Build with `cargo build --release -p horizon-client --example gameplay_decode_profile`.
 //! Each invocation runs one phase in a separate process for CPU/RSS measurements.
 #[allow(dead_code)]
-#[path = "../../horizon-items/src/blocks/decode.rs"]
+#[path = "../src/blocks/decode.rs"]
 mod decode;
 
 use std::{hint::black_box, path::Path, time::Instant};

crates/horizon-client/examples/mod_port_probe.rs

@@ -18,7 +18,6 @@ use horizon_client::{
 };
 use horizon_core::{geometry::Axis, random::LegacyRandom};
 use horizon_world::chunk::BlockState;
-use horizon_world::loot::PackOverlay;
 use serde_json::{Map, Value, json};
 use std::{collections::BTreeMap, fs, path::Path};
 
@@ -78,9 +77,9 @@ fn main() -> Result<()> {
     let assets = Assets::load(&root).map_err(step("assets"))?;
     let registry = assets.registry;
     let facts = BlockFacts::load(&root, registry).map_err(step("block facts"))?;
-    let items = Items::load(&root, registry, &facts, &PackOverlay::NONE).map_err(step("items"))?;
-    let recipes = Recipes::load(&root, &items, &PackOverlay::NONE).map_err(step("recipes"))?;
-    let stations = StationRecipes::load(&root, &items, &PackOverlay::NONE);
+    let items = Items::load(&root, registry, &facts).map_err(step("items"))?;
+    let recipes = Recipes::load(&root, &items).map_err(step("recipes"))?;
+    let stations = StationRecipes::load(&root, &items);
     let collisions =
         horizon_client::collisions::load(&root, registry).map_err(step("collisions"))?;
     let loaded = began.elapsed().as_secs_f64() - built;

crates/horizon-client/examples/portal_scan_bench.rs

@@ -7,7 +7,6 @@ use horizon_client::{
     chunk::{Chunk, MIN_Y, SECTIONS, Section},
     fast_hash::FxHashMap,
     portal_sections::PortalSections,
-    section_mask::SectionMask,
 };
 use horizon_core::{
     geometry::{Aabb, Vec3},
@@ -84,14 +83,17 @@ fn may_hold_portal_cached(
     if count > 64 {
         return true;
     }
-    let y_mask = SectionMask::below(y1 as usize + 1).from(y0 as usize);
+    let mut y_mask = 0u32;
+    for sy in y0..=y1 {
+        y_mask |= 1 << sy;
+    }
     (x0..=x1).any(|cx| {
         (z0..=z1).any(|cz| {
             world.get(&(cx, cz)).is_some_and(|chunk| {
-                let portals = cache.get((cx, cz), chunk, |v| {
+                cache.get((cx, cz), chunk, |v| {
                     behaviours.portal_axis(BlockStateId(v)).is_some()
-                });
-                !(portals & y_mask).is_empty()
+                }) & y_mask
+                    != 0
             })
         })
     })

crates/horizon-client/examples/probe/arrow_probe.rs

@@ -153,9 +153,6 @@ pub fn main() -> Result<()> {
                                 bits(position),
                                 bits(velocity)
                             )),
-                            ArrowEvent::PotionPuff { id, color } => {
-                                events.push(format!("potion-puff {id} {color:08x}"))
-                            }
                             ArrowEvent::Sound {
                                 sound,
                                 volume,
@@ -164,7 +161,6 @@ pub fn main() -> Result<()> {
                                 "sound {} {:08x} {:08x}",
                                 match sound {
                                     ArrowSound::HitGround => "hit",
-                                    ArrowSound::CrossbowHit => "crossbow_hit",
                                     ArrowSound::Splash => "splash",
                                     ArrowSound::Extinguish => "extinguish",
                                     ArrowSound::TridentHitGround => "trident_hit_ground",

crates/horizon-client/examples/probe/block_entity_anim_fixture.rs

@@ -16,7 +16,6 @@ use horizon_client::{
     items::Items,
 };
 use horizon_core::random::LegacyRandom;
-use horizon_world::loot::PackOverlay;
 use horizon_world::registry::{BlockRegistry, BlockStateId};
 use serde_json::Value;
 use std::{
@@ -128,7 +127,7 @@ pub fn main() -> Result<()> {
     let registry = assets.registry;
     let facts = BlockFacts::load(root, registry)?;
     let renderer = BlockEntityRenderer::load(root, registry)?;
-    let tags = Items::tags_only(root, &PackOverlay::NONE)?;
+    let tags = Items::tags_only(root)?;
     let frames = tags
         .block_tags
         .get("minecraft:conduit_effect_block")

crates/horizon-client/examples/probe/block_entity_render_fixture.rs

@@ -369,7 +369,6 @@ pub fn main() -> Result<()> {
             banner: &|_| layers.clone(),
             skull: &|_| None,
             glyph: &|c| atlas.glyph_cell(c),
-            glyphs: atlas.font.epoch(),
         };
         let mut verts = Vec::new();
         renderer.render_block(&scene, pos, state, Mat4::IDENTITY, packed, &mut verts);